Revised typed ClassDef construction.

2 files changed, 12 insertions, 11 deletions

diff --git a/src/dotty/tools/dotc/ast/TypedTrees.scala b/src/dotty/tools/dotc/ast/TypedTrees.scala
index 94c747ae1..a597261ae 100644
--- a/src/dotty/tools/dotc/ast/TypedTrees.scala
+++ b/src/dotty/tools/dotc/ast/TypedTrees.scala
@@ -238,25 +238,23 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     untpd.TypeDef(Modifiers(sym), sym.name, TypeTree(sym.info))
       .withType(refType(sym)).checked
 
-  def ClassDef(cls: ClassSymbol, typeParams: List[TypeSymbol], constr: DefDef, body: List[Tree])(implicit ctx: Context): TypeDef = {
+  def ClassDef(cls: ClassSymbol, constr: DefDef, body: List[Tree])(implicit ctx: Context): TypeDef = {
     val parents = cls.info.parents map (TypeTree(_))
     val selfType =
       if (cls.classInfo.optSelfType.exists) ValDef(ctx.newSelfSym(cls))
       else EmptyValDef
     def isOwnTypeParamAccessor(stat: Tree) =
       (stat.symbol is TypeParam) && stat.symbol.owner == cls
-    val (tparamAccessors, rest) = body partition isOwnTypeParamAccessor
-    val tparams =
-      (typeParams map TypeDef) ++
-        (tparamAccessors collect {
-          case td: TypeDef if !(typeParams contains td.symbol) => td
-        })
+    val bodyTypeParams = body filter isOwnTypeParamAccessor map (_.symbol)
+    val newTypeParams =
+      for (tparam <- cls.typeParams if !(bodyTypeParams contains tparam))
+      yield TypeDef(tparam)
     val findLocalDummy = new FindLocalDummyAccumulator(cls)
     val localDummy = ((NoSymbol: Symbol) /: body)(findLocalDummy)
       .orElse(ctx.newLocalDummy(cls))
-    val impl = untpd.Template(constr, parents, selfType, rest)
+    val impl = untpd.Template(constr, parents, selfType, newTypeParams ++ body)
       .withType(refType(localDummy)).checked
-    untpd.TypeDef(Modifiers(cls), cls.name, impl) // !!! todo: revise
+    untpd.TypeDef(Modifiers(cls), cls.name, impl)
       .withType(refType(cls)).checked
   }
 
@@ -327,7 +325,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def ModuleDef(sym: TermSymbol, body: List[Tree])(implicit ctx: Context): tpd.Thicket = {
     val modcls = sym.moduleClass.asClass
     val constr = DefDef(modcls.primaryConstructor.asTerm, EmptyTree)
-    val clsdef = ClassDef(modcls, Nil, constr, body)
+    val clsdef = ClassDef(modcls, constr, body)
     val valdef = ValDef(sym, New(modcls.typeConstructor))
     Thicket(valdef, clsdef)
   }
diff --git a/src/dotty/tools/dotc/core/pickling/UnPickler.scala b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
index 4c96c5e4b..23fb79f8f 100644
--- a/src/dotty/tools/dotc/core/pickling/UnPickler.scala
+++ b/src/dotty/tools/dotc/core/pickling/UnPickler.scala
@@ -897,7 +897,10 @@ class UnPickler(bytes: Array[Byte], classRoot: ClassDenotation, moduleClassRoot:
         setSymModsName()
         val impl = readTemplateRef()
         val tparams = until(end, readTypeDefRef)
-        ClassDef(symbol.asClass, tparams map (_.symbol.asType), ???, impl.body) // !!! TODO: pull out primary constructor
+        val cls = symbol.asClass
+        val ((constr: DefDef) :: Nil, stats) =
+          impl.body.partition(_.symbol == cls.primaryConstructor)
+        ClassDef(cls, constr, tparams ++ stats)
 
       case MODULEtree =>
         setSymModsName()