fix #11819: Fix comparisons against thisType

We cannot assume that all equivalent ThisType have the same
identity (even with hash-consing, they can be constructed from different
but equivalent TypeRefs).

Co-authored-by: Guillaume Martres <[email protected]>

Author: bishabosha

compiler/src/dotty/tools/dotc/core/Denotations.scala

@@ -1110,7 +1110,11 @@ object Denotations {
         case sd: SymDenotation => true
         case _ => info eq symbol.info
 
-      if !owner.membersNeedAsSeenFrom(pre) && ((pre ne owner.thisType) || hasOriginalInfo)
+      def ownerIsPrefix = pre match
+        case pre: ThisType => pre.sameThis(owner.thisType)
+        case _ => false
+
+      if !owner.membersNeedAsSeenFrom(pre) && (!ownerIsPrefix || hasOriginalInfo)
          || symbol.is(NonMember)
       then this
       else derived(symbol.info)

compiler/src/dotty/tools/dotc/core/SymDenotations.scala

@@ -896,11 +896,14 @@ object SymDenotations {
      *  accessed via prefix `pre`?
      */
     def membersNeedAsSeenFrom(pre: Type)(using Context): Boolean =
+      def preIsThis = pre match
+        case pre: ThisType => pre.sameThis(thisType)
+        case _ => false
       !(  this.isTerm
        || this.isStaticOwner && !this.seesOpaques
        || ctx.erasedTypes
        || (pre eq NoPrefix)
-       || (pre eq thisType)
+       || preIsThis
        )
 
     /** Is this symbol concrete, or that symbol deferred? */

compiler/src/dotty/tools/dotc/core/Types.scala

@@ -2663,8 +2663,11 @@ object Types {
    *  the future. See also NamedType#withDenot. Test case is neg/opaque-self-encoding.scala.
    */
   private def designatorFor(prefix: Type, name: Name, denot: Denotation)(using Context): Designator = {
+    def ownerIsPrefix(owner: Symbol) = prefix match
+      case prefix: ThisType => prefix.sameThis(owner.thisType)
+      case _ => false
     val sym = denot.symbol
-    if (sym.exists && (prefix.eq(NoPrefix) || prefix.ne(sym.owner.thisType)))
+    if (sym.exists && (prefix.eq(NoPrefix) || !ownerIsPrefix(sym.owner)))
       sym
     else
       name
@@ -2736,6 +2739,12 @@ object Types {
       case that: ThisType => tref.eq(that.tref)
       case _ => false
     }
+
+    /** Check that the rhs is a ThisType that refers to the same class.
+     */
+    def sameThis(that: Type)(using Context): Boolean = (that eq this) || that.match
+      case that: ThisType => this.cls eq that.cls
+      case _ => false
   }
 
   final class CachedThisType(tref: TypeRef) extends ThisType(tref)

tests/pos/i11819.scala

@@ -0,0 +1,12 @@
+package opaquetypes
+
+object `package`: // must be a package object
+
+  opaque type Foo = Double // `Foo` must be an opaque type, reference must be primitive
+
+  object Bar: // must have a wrapper object
+
+    class Baz(val i: Foo): // must be an unqualified reference to `Foo`
+      def foo(that: Any): Boolean = that match
+        case that1 @ (_: Baz) => Baz.this.i == that1.i // error: symbol for `==` changed
+        case _ => true