Don't change parents in specializeFunctions

Author: Duhemm

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

@@ -248,7 +248,7 @@ object NameOps {
     /** This method is to be used on **type parameters** from a class, since
      *  this method does sorting based on their names
      */
-    def specializedFor(classTargs: List[Types.Type], classTargsNames: List[Name], methodTargs: List[Types.Type], methodTarsNames: List[Name])(implicit ctx: Context): name.ThisName = {
+    def specializedFor(classTargs: List[Types.Type], classTargsNames: List[Name], methodTargs: List[Types.Type], methodTarsNames: List[Name])(implicit ctx: Context): Name = {
       val methodTags: Seq[Name] = (methodTargs zip methodTarsNames).sortBy(_._2).map(x => typeToTag(x._1))
       val classTags: Seq[Name] = (classTargs zip classTargsNames).sortBy(_._2).map(x => typeToTag(x._1))
 
@@ -263,7 +263,7 @@ object NameOps {
      *
      *  `<return type><first type><second type><...>`
      */
-    def specializedFunction(ret: Types.Type, args: List[Types.Type])(implicit ctx: Context): name.ThisName =
+    def specializedFunction(ret: Types.Type, args: List[Types.Type])(implicit ctx: Context): Name =
       name ++ nme.specializedTypeNames.prefix ++
       nme.specializedTypeNames.separator ++ typeToTag(ret) ++
       args.map(typeToTag).fold(nme.EMPTY)(_ ++ _) ++ nme.specializedTypeNames.suffix

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

@@ -38,7 +38,7 @@ object Names {
   abstract class Name extends Designator with PreName { self =>
 
     /** A type for names of the same kind as this name */
-    type ThisName <: Name { type ThisName = self.ThisName }
+    type ThisName <: Name
 
     /** Is this name a type name? */
     def isTypeName: Boolean

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

@@ -32,49 +32,39 @@ class SpecializeFunctions extends MiniPhaseTransform with InfoTransformer {
     case tp: ClassInfo if !sym.is(Flags.Package) && (tp.decls ne EmptyScope) => {
       var newApplys = Map.empty[Name, Symbol]
 
-      val newParents = tp.parents.mapConserve { parent =>
-        List(0, 1, 2, 3).flatMap { arity =>
+      tp.parents.foreach { parent =>
+        List(0, 1, 2, 3).foreach { arity =>
           val func = defn.FunctionClass(arity)
           if (!parent.derivesFrom(func)) Nil
           else {
             val typeParams = tp.cls.typeRef.baseType(func).argInfos
-            val interface = specInterface(typeParams)
+            val interface  = specInterface(typeParams)
 
             if (interface.exists) {
               if (tp.decls.lookup(nme.apply).exists) {
                 val specializedMethodName = nme.apply.specializedFunction(typeParams.last, typeParams.init)
-                newApplys = newApplys + (specializedMethodName -> interface)
+                newApplys += (specializedMethodName -> interface)
               }
-
-              if (parent.isRef(func)) List(interface.typeRef)
-              else Nil
             }
-            else Nil
           }
         }
-        .headOption
-        .getOrElse(parent)
       }
 
       def newDecls =
-        if (newApplys.isEmpty) tp.decls
-        else
-          newApplys.toList.map { case (name, interface) =>
-            ctx.newSymbol(
-              sym,
-              name,
-              Flags.Override | Flags.Method,
-              interface.info.decls.lookup(name).info
-            )
-          }
-          .foldLeft(tp.decls.cloneScope) {
-            (scope, sym) => scope.enter(sym); scope
-          }
+        newApplys.toList.map { case (name, interface) =>
+          ctx.newSymbol(
+            sym,
+            name,
+            Flags.Override | Flags.Method,
+            interface.info.decls.lookup(name).info
+          )
+        }
+        .foldLeft(tp.decls.cloneScope) {
+          (scope, sym) => scope.enter(sym); scope
+        }
 
-      tp.derivedClassInfo(
-        classParents = newParents,
-        decls = newDecls
-      )
+      if (newApplys.isEmpty) tp
+      else tp.derivedClassInfo(decls = newDecls)
     }
 
     case _ => tp
@@ -95,15 +85,6 @@ class SpecializeFunctions extends MiniPhaseTransform with InfoTransformer {
         )
 
         val specializedApply = tree.symbol.enclosingClass.info.decls.lookup(specName)//member(specName).symbol
-        //val specializedApply = tree.symbol.enclosingClass.info.member(specName).symbol
-
-        if (false) {
-          println(tree.symbol.enclosingClass.show)
-          println("'" + specName.show + "'")
-          println(specializedApply)
-          println(specializedApply.exists)
-        }
-
 
         if (specializedApply.exists) {
           val apply = specializedApply.asTerm
@@ -126,22 +107,7 @@ class SpecializeFunctions extends MiniPhaseTransform with InfoTransformer {
       case x => x
     }
 
-    val missing: List[TypeTree] = List(0, 1, 2, 3).flatMap { arity =>
-      val func = defn.FunctionClass(arity)
-      val tr = tree.symbol.enclosingClass.typeRef
-
-      if (!tr.parents.exists(_.isRef(func))) Nil
-      else {
-        val typeParams = tr.baseType(func).argInfos
-        val interface = specInterface(typeParams)
-
-        if (interface.exists) List(interface.info)
-        else Nil
-      }
-    }.map(TypeTree _)
-
     cpy.Template(tree)(
-      parents = tree.parents ++ missing,
       body = applyBuf.toList ++ newBody
     )
   }