Merge pull request #2889 from dotty-staging/fix#-2888

Fix #2888: Avoid caching supertypes of hk apps with provisional infos

Author: odersky

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

@@ -424,6 +424,9 @@ object Flags {
   /** A method that is known to have no default parameters */
   final val NoDefaultParams = termFlag(61, "<no-default-param>")
 
+  /** A type symbol with provisional empty bounds */
+  final val Provisional = typeFlag(61, "<provisional>")
+
   /** A denotation that is valid in all run-ids */
   final val Permanent = commonFlag(62, "<permanent>")
 

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

@@ -3012,15 +3012,18 @@ object Types {
 
     override def superType(implicit ctx: Context): Type = {
       if (ctx.period != validSuper) {
+        validSuper = ctx.period
         cachedSuper = tycon match {
           case tp: HKTypeLambda => defn.AnyType
           case tp: TypeVar if !tp.inst.exists =>
             // supertype not stable, since underlying might change
-            return tp.underlying.applyIfParameterized(args)
-          case tp: TypeProxy => tp.superType.applyIfParameterized(args)
+            validSuper = Nowhere
+            tp.underlying.applyIfParameterized(args)
+          case tp: TypeProxy =>
+            if (tp.typeSymbol.is(Provisional)) validSuper = Nowhere
+            tp.superType.applyIfParameterized(args)
           case _ => defn.AnyType
         }
-        validSuper = ctx.period
       }
       cachedSuper
     }

compiler/src/dotty/tools/dotc/typer/Namer.scala

@@ -1159,6 +1159,7 @@ class Namer { typer: Typer =>
     def abstracted(tp: Type): Type = HKTypeLambda.fromParams(tparamSyms, tp)
     val dummyInfo = abstracted(TypeBounds.empty)
     sym.info = dummyInfo
+    sym.setFlag(Provisional)
       // Temporarily set info of defined type T to ` >: Nothing <: Any.
       // This is done to avoid cyclic reference errors for F-bounds.
       // This is subtle: `sym` has now an empty TypeBounds, but is not automatically

tests/pos/i2888.scala

@@ -0,0 +1,13 @@
+trait Foo[A, CC[X] <: Foo[X, CC, CC[X]], C <: CC[A]] {
+
+  def cc: CC[A]
+
+  def foo: Unit = ()
+
+  def bar: Unit = cc.foo
+
+}
+
+object Main {
+  def main(args: Array[String]): Unit = ()
+}