Fix isSubType for static objects filling in type projections

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

@@ -311,8 +311,7 @@ class TypeComparer(@constructorOnly initctx: Context) extends ConstraintHandling
                 thirdTryNamed(tp2)
               else
                 (  (tp1.name eq tp2.name)
-                && tp1.isMemberRef
-                && tp2.isMemberRef
+                && tp2.isPrefixDependentMemberRef
                 && isSubPrefix(tp1.prefix, tp2.prefix)
                 && tp1.signature == tp2.signature
                 && !(sym1.isClass && sym2.isClass)  // class types don't subtype each other

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

@@ -2496,8 +2496,10 @@ object Types {
       symd.maybeOwner.membersNeedAsSeenFrom(prefix) && !symd.is(NonMember)
       || prefix.isInstanceOf[Types.ThisType] && symd.is(Opaque) // see pos/i11277.scala for a test where this matters
 
-    /** Is this a reference to a class or object member? */
-    def isMemberRef(using Context): Boolean = designator match {
+    /** Is this a reference to a class or object member with an info that might depend
+     *  on the prefix?
+     */
+    def isPrefixDependentMemberRef(using Context): Boolean = designator match {
       case sym: Symbol => infoDependsOnPrefix(sym, prefix)
       case _ => true
     }

compiler/src/dotty/tools/dotc/transform/TreeChecker.scala

@@ -385,7 +385,7 @@ class TreeChecker extends Phase with SymTransformer {
 
       val sym = tree.symbol
       val symIsFixed = tpe match {
-        case tpe: TermRef => ctx.erasedTypes || !tpe.isMemberRef
+        case tpe: TermRef => ctx.erasedTypes || !tpe.isPrefixDependentMemberRef
         case _ => false
       }
       if (sym.exists && !sym.is(Private) &&

tests/pos/i15931.scala

@@ -0,0 +1,24 @@
+sealed trait TP:
+  type C
+  type P
+
+final class Foo extends TP:
+  class C
+  enum P:
+    case A, B
+
+object Bar extends TP:
+  class C
+  enum P:
+    case A, B, C
+
+// Works
+def test =
+  summon[Foo#P <:< TP#P]
+  val a: TP#P = Foo().P.A
+
+  // These fail
+  val b: TP#P = Bar.P.A: Bar.P
+  summon[Bar.type#P <:< TP#P]
+  summon[Bar.P <:< TP#P]
+  val c: TP#C = ??? : Bar.C