Opaque type not transparent when seen from a computed prefix

[smarter]

class Foo {
  opaque type Num = Int

  val z = Test.id(this)(1)
}
object Test {
  def id(f: Foo)(x: f.Num): f.Num = x
}

-- [E007] Type Mismatch Error: try/opaque.scala:4:24 ---------------------------
4 |  val z = Test.id(this)(1)
  |                        ^
  |                        Found:    (1 : Int)
  |                        Required: Foo.this.Num

As far as I can tell, the issue is that infoDependsOnPrefix is defined as:
https://github.com/lampepfl/dotty/blob/3b741d67f8631487aa553c52e03ac21157e68563/compiler/src/dotty/tools/dotc/core/Types.scala#L2300-L2301
And membersNeedAsSeenFrom returns true when the prefix is the current thisType, because we don't actually need to do an as-seen-from. But for opaque types we do need to recompute the info as a member of its thisType prefix to reveal the opaque type alias, so my best bet is that we need something like this:

--- compiler/src/dotty/tools/dotc/core/Types.scala
+++ compiler/src/dotty/tools/dotc/core/Types.scala
@@ -2302,6 +2302,7 @@ object Types {
      */
     private def infoDependsOnPrefix(symd: SymDenotation, prefix: Type)(using Context): Boolean =
       symd.maybeOwner.membersNeedAsSeenFrom(prefix) && !symd.is(NonMember)
+      || prefix.isInstanceOf[Types.ThisType] && symd.is(Opaque)

     /** Is this a reference to a class or object member? */
     def isMemberRef(using Context): Boolean = designator match {

Which does fix the original issue, but I don't understand the full opaque type implementation well enough to say if this is good enough (for example there's a seemingly related special case in https://github.com/lampepfl/dotty/blob/3b741d67f8631487aa553c52e03ac21157e68563/compiler/src/dotty/tools/dotc/core/Denotations.scala#L1066-L1076, and I have no idea why). WDYT @odersky ?

[odersky]

It is inherent in opaque types that they are opaque when used from a prefix. After all, the alias is recorded in the self type of the enclosing class, and that self type is only visible if the prefix is this. So you can think of opaque types as private[this] transparent.

[odersky]

It would be good to update the docs to reflect this.

[smarter]

It is inherent in opaque types that they are opaque when used from a prefix.

This is not true when the prefix in question is the ThisType of the type defining the opaque type:

class Foo {
  opaque type Num = Int

  val z: Foo.this.Num = 1
}

This works perfectly well, which is not surprising: Num and Foo.this.Num are exactly the same type, it's just that one is written with a qualifier elided and the other isn't. But the error message I got above was:

-- [E007] Type Mismatch Error: try/opaque.scala:4:24 ---------------------------
4 |  val z = Test.id(this)(1)
  |                        ^
  |                        Found:    (1 : Int)
  |                        Required: Foo.this.Num

This again mentions Foo.this.Num, bu this time the compiler doesn't think that Int is a subtype of that type, but it's exactly the same type that works when you write it manually! The only difference is that the compiler created these types in different ways and ended up assigning them different denotations, this is purely an implementation detail and I don't see how this could be specified.