Compute type params in namer without completing the whole info

Type params should be computed before computing the whole info of
a type. Without the patch we get a cycluc reference in the compileMixed
test.

Author: odersky

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

@@ -1782,9 +1782,6 @@ 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
@@ -1805,6 +1802,14 @@ object SymDenotations {
     def withModuleClass(moduleClassFn: Context => Symbol): this.type = { myModuleClassFn = moduleClassFn; this }
   }
 
+  /** A subclass of LazyTypes where type parameters can be completed independently of
+   *  the info.
+   */
+  abstract class TypeParamsCompleter extends LazyType {
+    /** The type parameters computed by the completer before completion has finished */
+    def completerTypeParams(sym: Symbol): List[TypeSymbol]
+  }
+
   val NoSymbolFn = (ctx: Context) => NoSymbol
 
   /** A missing completer */

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

@@ -4,6 +4,7 @@ package core
 import Types._
 import Contexts._
 import Symbols._
+import SymDenotations.TypeParamsCompleter
 import Decorators._
 import util.Stats._
 import util.common._
@@ -240,14 +241,21 @@ 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) 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.
-        else tsym.info.typeParams
+        else tsym.infoOrCompleter match {
+          case completer: TypeParamsCompleter =>
+            val tparams = completer.completerTypeParams(tsym)
+            if (tsym.isClass) tparams
+            else defn.LambdaTrait(tparams.map(_.variance)).typeParams
+          case _ =>
+            if (!tsym.isCompleting || tsym.isAliasType) tsym.info.typeParams
+            else
+              // 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 needed.
+              Nil
+        }
       case self: RefinedType =>
         // inlined and optimized version of
         //   val sym = self.LambdaTrait

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

@@ -478,14 +478,14 @@ class Namer { typer: Typer =>
   }
 
   /** The completer of a symbol defined by a member def or import (except ClassSymbols) */
-  class Completer(val original: Tree)(implicit ctx: Context) extends LazyType {
+  class Completer(val original: Tree)(implicit ctx: Context) extends TypeParamsCompleter {
 
     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] = {
+    def completerTypeParams(sym: Symbol): List[TypeSymbol] = {
       if (myTypeParams == null) {
         //println(i"completing type params of $sym in ${sym.owner}")
         myTypeParams = original match {

test/dotc/tests.scala

@@ -186,6 +186,13 @@ class tests extends CompilerTest {
    .toList
 
   @Test def compileStdLib = compileList("compileStdLib", stdlibFiles, "-migration" :: scala2mode)
+  @Test def compileMixed = compileLine(
+      """tests/pos/B.scala
+        |./scala-scala/src/library/scala/collection/immutable/Seq.scala
+        |./scala-scala/src/library/scala/package.scala
+        |./scala-scala/src/library/scala/collection/GenSeqLike.scala
+        |./scala-scala/src/library/scala/collection/SeqLike.scala
+        |./scala-scala/src/library/scala/collection/generic/GenSeqFactory.scala""".stripMargin)
   @Test def compileIndexedSeq = compileLine("./scala-scala/src/library/scala/collection/immutable/IndexedSeq.scala")
 
   @Test def dotty = compileDir(dottyDir, ".", List("-deep", "-Ycheck-reentrant"))(allowDeepSubtypes) // note the -deep argument

tests/pos/B.scala

@@ -0,0 +1,6 @@
+object B{
+  def main(args: Array[String]): Unit = {
+    val s = List(1,2,3)
+    ()
+  }
+}