Implement type specialization with specified Types.

Author: AlexSikia

src/dotty/tools/dotc/transform/TypeSpecializer.scala

@@ -20,7 +20,8 @@ class TypeSpecializer extends MiniPhaseTransform {
   private val specializationRequests: mutable.HashMap[Symbols.Symbol, List[List[Type]]] = mutable.HashMap.empty
 
   def registerSpecializationRequest(method: Symbols.Symbol)(arguments: List[Type])(implicit ctx: Context) = {
-    //assert(ctx.phaseId <= this.period.phaseId) // This fails - why ?
+    if(ctx.phaseId > this.treeTransformPhase.id)
+      assert(ctx.phaseId <= this.treeTransformPhase.id)
     val prev = specializationRequests.getOrElse(method, List.empty)
     specializationRequests.put(method, arguments :: prev)
   }
@@ -49,6 +50,7 @@ class TypeSpecializer extends MiniPhaseTransform {
 
   def specializeForAll(sym: Symbols.Symbol)(implicit ctx: Context): List[List[Type]] = {
     registerSpecializationRequest(sym)(specialisedType2Suffix.keys.toList)
+    println("Specializing for all primitive types")
     specializationRequests.getOrElse(sym, Nil)
   }
 
@@ -59,29 +61,31 @@ class TypeSpecializer extends MiniPhaseTransform {
   }
 
   def shouldSpecializeFor(sym: Symbols.Symbol)(implicit ctx: Context): List[List[Type]] = {
-    if (sym.denot.hasAnnotation(ctx.definitions.specializedAnnot)) {
-      val specAnnotation = sym.denot.getAnnotation(ctx.definitions.specializedAnnot).getOrElse(Nil)
-      specAnnotation.asInstanceOf[Annotation].arguments match {
-        case List(SeqLiteral(types)) => specializeForSome(sym)(types.map(tpeTree => name2SpecialisedType(ctx)(tpeTree.tpe.asInstanceOf[TermRef].name.toString())))
-        case List() => specializeForAll(sym)
+      sym.denot.getAnnotation(ctx.definitions.specializedAnnot).getOrElse(Nil) match {
+        case annot: Annotation =>
+          annot.arguments match {
+            case List(SeqLiteral(types)) =>
+              specializeForSome(sym)(types.map(tpeTree =>
+                name2SpecialisedType(ctx)(tpeTree.tpe.asInstanceOf[TermRef].name.toString())))
+            case List() => specializeForAll(sym)
+          }
+        case nil =>
+          if(ctx.settings.Yspecialize.value == "all") specializeForAll(sym)
+          else Nil
       }
-    }
-    else if(ctx.settings.Yspecialize.value == "all") specializeForAll(sym)
-    else Nil
   }
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
 
     tree.tpe.widen match {
-        
+
       case poly: PolyType if !(tree.symbol.isPrimaryConstructor
                                || (tree.symbol is Flags.Label)) => {
         val origTParams = tree.tparams.map(_.symbol)
         val origVParams = tree.vparamss.flatten.map(_.symbol)
-        println(s"specializing ${tree.symbol} for Tparams: ${origTParams}")
+        println(s"specializing ${tree.symbol} for Tparams: $origTParams")
 
         def specialize(instatiations: List[Type], names: List[String]): Tree = {
-
           val newSym = ctx.newSymbol(tree.symbol.owner, (tree.name + names.mkString).toTermName, tree.symbol.flags | Flags.Synthetic, poly.instantiate(instatiations.toList))
           polyDefDef(newSym, { tparams => vparams => {
             assert(tparams.isEmpty)
@@ -102,10 +106,9 @@ class TypeSpecializer extends MiniPhaseTransform {
           if (remainingTParams.nonEmpty) {
             val typeToSpecialize = remainingTParams.head
             val bounds = remainingBounds.head
-            val specializeFor = shouldSpecializeFor(typeToSpecialize.symbol).flatten
-            println(s"types to specialize for are : $specializeFor")
-
-            specializeFor.filter{ tpe =>
+            shouldSpecializeFor(typeToSpecialize.symbol)
+              .flatten
+              .filter{ tpe =>
               bounds.contains(tpe)
             }.flatMap { tpe =>
               val nme = specialisedType2Suffix(ctx)(tpe)

test/dotc/tests.scala

@@ -29,7 +29,6 @@ class tests extends CompilerTest {
   val staleSymbolError: List[String] = List()
 
   val allowDeepSubtypes = defaultOptions diff List("-Yno-deep-subtypes")
-<<<<<<< HEAD
   val allowDoubleBindings = defaultOptions diff List("-Yno-double-bindings")
 
   val testsDir      = "./tests/"
@@ -45,6 +44,7 @@ class tests extends CompilerTest {
   val dotcDir   = toolsDir + "dotc/"
   val coreDir   = dotcDir + "core/"
 
+  /*
   @Test def pickle_pickleOK = compileDir(testsDir, "pickling", testPickling)
 // This directory doesn't exist anymore
 // @Test def pickle_pickling = compileDir(coreDir, "pickling", testPickling)
@@ -90,6 +90,15 @@ class tests extends CompilerTest {
 
   @Test def pos_all = compileFiles(posDir) // twice omitted to make tests run faster
 
+  @Test def pos_specialization = compileFile(posDir, "specialization")
+
+// contains buggy tests
+  @Test def pos_all = compileFiles(posDir, failedOther)
+
+  */@Test def pos_SI7638 = compileFile(posDir, "SI-7638")/*
+  @Test def pos_SI7638a = compileFile(posDir, "SI-7638a")
+
+
   @Test def new_all = compileFiles(newDir, twice)
 
   @Test def neg_blockescapes() = compileFile(negDir, "blockescapesNeg", xerrors = 1)
@@ -140,37 +149,28 @@ class tests extends CompilerTest {
   @Test def neg_selfInheritance = compileFile(negDir, "selfInheritance", xerrors = 5)
 
   @Test def dotc = compileDir(dotcDir + "tools/dotc", failedOther)(allowDeepSubtypes)
-//buggy ->
   @ Test def dotc_ast = compileDir(dotcDir + "tools/dotc/ast", failedOther) // similar to dotc_config
   @Test def dotc_config = compileDir(dotcDir + "tools/dotc/config_debug", failedOther) // seems to mess up stack frames
-//buggy ->
   @ Test def dotc_core = compileDir(dotcDir + "tools/dotc/core", failedUnderscore)(allowDeepSubtypes)
   // fails due to This refference to a non-eclosing class. Need to check
 
-//buggy ->
   @ Test def dotc_core_pickling = compileDir(dotcDir + "tools/dotc/core/pickling", failedOther)(allowDeepSubtypes) // Cannot emit primitive conversion from V to Z
 
-//buggy ->
   @ Test def dotc_transform = compileDir(dotcDir + "tools/dotc/transform", failedbyName)
 
-//buggy ->
   @ Test def dotc_parsing = compileDir(dotcDir + "tools/dotc/parsing", failedOther)
     //  Expected primitive types I - Ljava/lang/Object
     //  Tried to return an object where expected type was Integer
-//buggy ->
   @ Test def dotc_printing = compileDir(dotcDir + "tools/dotc/printing", failedOther)
   @Test def dotc_reporting = compileDir(dotcDir + "tools/dotc/reporting", twice)
-//buggy ->
   @Test def dotc_typer = compileDir(dotcDir + "tools/dotc/typer", failedOther) // similar to dotc_config
   //@Test def dotc_util = compileDir(dotcDir + "tools/dotc/util") //fails inside ExtensionMethods with ClassCastException
-//buggy ->
   @Test def tools_io = compileDir(dotcDir + "tools/io", failedOther) // similar to dotc_config
 
   @Test def helloWorld = compileFile(posDir, "HelloWorld", doEmitBytecode)
   @Test def labels = compileFile(posDir, "Labels", doEmitBytecode)
   //@Test def tools = compileDir(dotcDir + "tools", "-deep" :: Nil)(allowDeepSubtypes)
 
-//buggy ->
   @ Test def testNonCyclic = compileArgs(Array(
       dotcDir + "tools/dotc/CompilationUnit.scala",
       dotcDir + "tools/dotc/core/Types.scala",
@@ -190,10 +190,12 @@ class tests extends CompilerTest {
   @Test def dotc_config = compileDir(dotcDir, "config")
   @Test def dotc_core = compileDir(dotcDir, "core")("-Yno-double-bindings" :: allowDeepSubtypes)// twice omitted to make tests run faster
 
+
   @Test def dotc_core_pickling = compileDir(coreDir, "pickling")(allowDeepSubtypes)// twice omitted to make tests run faster
 
   @Test def dotc_transform = compileDir(dotcDir, "transform")// twice omitted to make tests run faster
-  
+
+*/
   //@Test def dotc_compilercommand = compileFile(dotcDir + "tools/dotc/config/", "CompilerCommand")
 
   @Test def dotc_parsing = compileDir(dotcDir, "parsing") // twice omitted to make tests run faster