Make Namer completers complete type params without doing a full completion

Author: odersky

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

@@ -1782,6 +1782,9 @@ object SymDenotations {
     def apply(sym: Symbol) = this
     def apply(module: TermSymbol, modcls: ClassSymbol) = this
 
+    /** The type parameters computed by the completer before completion has finished */
+    def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol] = Nil
+
     private var myDecls: Scope = EmptyScope
     private var mySourceModuleFn: Context => Symbol = NoSymbolFn
     private var myModuleClassFn: Context => Symbol = NoSymbolFn

src/dotty/tools/dotc/core/TypeApplications.scala

@@ -240,14 +240,13 @@ class TypeApplications(val self: Type) extends AnyVal {
       case self: TypeRef =>
         val tsym = self.symbol
         if (tsym.isClass) tsym.typeParams
-        else if (tsym.isAliasType) self.underlying.typeParams
-        else if (tsym.isCompleting)
+        //else if (tsym.isAliasType) self.underlying.typeParams
+        else if (tsym.isCompleting) tsym.completer.completerTypeParams(tsym)
           // We are facing a problem when computing the type parameters of an uncompleted
           // abstract type. We can't access the bounds of the symbol yet because that
           // would cause a cause a cyclic reference. So we return `Nil` instead
           // and try to make up for it later. The acrobatics in Scala2Unpicker#readType
           // for reading a TypeRef show what's neeed.
-          Nil
         else tsym.info.typeParams
       case self: RefinedType =>
         // inlined and optimized version of

src/dotty/tools/dotc/core/TypeOps.scala

@@ -35,7 +35,7 @@ trait TypeOps { this: Context => // TODO: Make standalone object.
    *  Instead we produce an annotated type that marks the prefix as unsafe:
    *
    *     (x: (C @ UnsafeNonvariant)#T)C#T
-   
+
    *  We also set a global state flag `unsafeNonvariant` to the current run.
    *  When typing a Select node, typer will check that flag, and if it
    *  points to the current run will scan the result type of the select for

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

@@ -482,6 +482,27 @@ class Namer { typer: Typer =>
 
     protected def localContext(owner: Symbol) = ctx.fresh.setOwner(owner).setTree(original)
 
+    private var myTypeParams: List[TypeSymbol] = null
+    private var nestedCtx: Context = null
+
+    override def completerTypeParams(sym: Symbol)(implicit ctx: Context): List[TypeSymbol] = {
+      if (myTypeParams == null) {
+        //println(i"completing type params of $sym in ${sym.owner}")
+        myTypeParams = original match {
+          case tdef: TypeDef =>
+            nestedCtx = localContext(sym).setNewScope
+            locally {
+              implicit val ctx: Context = nestedCtx
+              completeParams(tdef.tparams)
+              tdef.tparams.map(symbolOfTree(_).asType)
+            }
+          case _ =>
+            Nil
+        }
+      }
+      myTypeParams
+    }
+
     private def typeSig(sym: Symbol): Type = original match {
       case original: ValDef =>
         if (sym is Module) moduleValSig(sym)
@@ -492,7 +513,7 @@ class Namer { typer: Typer =>
         typer1.defDefSig(original, sym)(localContext(sym).setTyper(typer1))
       case original: TypeDef =>
         assert(!original.isClassDef)
-        typeDefSig(original, sym)(localContext(sym).setNewScope)
+        typeDefSig(original, sym, completerTypeParams(sym))(nestedCtx)
       case imp: Import =>
         try {
           val expr1 = typedAheadExpr(imp.expr, AnySelectionProto)
@@ -840,9 +861,7 @@ class Namer { typer: Typer =>
     else valOrDefDefSig(ddef, sym, typeParams, paramSymss, wrapMethType)
   }
 
-  def typeDefSig(tdef: TypeDef, sym: Symbol)(implicit ctx: Context): Type = {
-    completeParams(tdef.tparams)
-    val tparamSyms = tdef.tparams map symbolOfTree
+  def typeDefSig(tdef: TypeDef, sym: Symbol, tparamSyms: List[TypeSymbol])(implicit ctx: Context): Type = {
     val isDerived = tdef.rhs.isInstanceOf[untpd.DerivedTypeTree]
     //val toParameterize = tparamSyms.nonEmpty && !isDerived
     //val needsLambda = sym.allOverriddenSymbols.exists(_ is HigherKinded) && !isDerived