Move TypeSpecializer before ElimByName and implement check for @specialized

Author: AlexSikia

src/dotty/tools/dotc/Compiler.scala

@@ -50,14 +50,16 @@ class Compiler {
       List(new PatternMatcher,
            new ExplicitOuter,
            new Splitter),
-      List(new SeqLiterals,
+      List(new TypeSpecializer),
+      List(new LazyVals,
+           new ElimByName,
+           new SeqLiterals,
            new InterceptedMethods,
            new Literalize,
            new Getters,
            new ClassTags,
            new ElimByName,
            new ResolveSuper),
-      List(new TypeSpecializer),
       List(new Erasure),
       List(new ElimErasedValueType,
            new VCInline,

src/dotty/tools/dotc/config/ScalaSettings.scala

@@ -152,6 +152,7 @@ class ScalaSettings extends Settings.SettingGroup {
   val YnoDeepSubtypes = BooleanSetting("-Yno-deep-subtypes", "throw an exception on deep subtyping call stacks.")
   val YprintSyms = BooleanSetting("-Yprint-syms", "when printing trees print info in symbols instead of corresponding info in trees.")
   val YtestPickler = BooleanSetting("-Ytest-pickler", "self-test for pickling functionality; should be used with -Ystop-after:pickler")
+  val Yspecialize = StringSetting("-Yspecialize","","Specialize all methods.","") // How should the second and fourth paramerters be initialised ?
   def stop = YstopAfter
 
   /** Area-specific debug output.

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

@@ -326,6 +326,7 @@ class Definitions {
   lazy val TransientAnnot                = ctx.requiredClass("scala.transient")
   lazy val NativeAnnot                   = ctx.requiredClass("scala.native")
   lazy val ScalaStrictFPAnnot            = ctx.requiredClass("scala.annotation.strictfp")
+  lazy val specializedAnnot              = ctx.requiredClass("scala.specialized")
 
   // Annotation classes
   lazy val AliasAnnot = ctx.requiredClass("dotty.annotation.internal.Alias")

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

@@ -3,18 +3,26 @@ package dotty.tools.dotc.transform
 import dotty.tools.dotc.ast.TreeTypeMap
 import dotty.tools.dotc.ast.tpd._
 import dotty.tools.dotc.core.Contexts.Context
-import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.{Symbols, Flags}
 import dotty.tools.dotc.core.Types._
 import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, MiniPhaseTransform}
 import dotty.tools.dotc.core.Decorators._
-import scala.collection.mutable.{ListBuffer, ArrayBuffer}
+import scala.collection.mutable
 
 class TypeSpecializer extends MiniPhaseTransform {
 
-  override def phaseName = "Type Specializer"
+  override def phaseName = "specialize"
 
   final val maxTparamsToSpecialize = 2
-  
+
+  private val specializationRequests: mutable.HashMap[Symbol, List[List[Type]]] = mutable.HashMap.empty
+
+  def registerSpecializationRequest(method: Symbol)(arguments: List[Type])(implicit ctx: Context) = {
+    assert(ctx.phaseId <= this.period.phaseId)
+    val prev = specializationRequests.getOrElse(method, List.empty)
+    specializationRequests.put(method, arguments :: prev)
+  }
+
   private final def specialisedTypes(implicit ctx: Context) =
     Map(ctx.definitions.ByteType -> "$mcB$sp",
     ctx.definitions.BooleanType -> "$mcZ$sp",
@@ -25,24 +33,30 @@ class TypeSpecializer extends MiniPhaseTransform {
     ctx.definitions.DoubleType -> "$mcD$sp",
     ctx.definitions.CharType -> "$mcC$sp",
     ctx.definitions.UnitType -> "$mcV$sp")
-  
+
+  def shouldSpecializeForAll(sym: Symbols.Symbol)(implicit ctx: Context): Boolean = {
+    // either -Yspecialize:all is given, or sym has @specialize annotation
+    sym.denot.hasAnnotation(ctx.definitions.specializedAnnot) || (ctx.settings.Yspecialize.value == "all")
+  }
+
+  def shouldSpecializeForSome(sym: Symbol)(implicit ctx: Context): List[List[Type]] = {
+    specializationRequests.getOrElse(sym, Nil)
+  }
+
+
+
+
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
 
-    def rewireType(tpe: Type) = tpe match {
-        case tpe: TermRef => tpe.widen
-        case _ => tpe
-      }
-    
     tree.tpe.widen match {
 
       case poly: PolyType if !(tree.symbol.isPrimaryConstructor
-                               || (tree.symbol is Flags.Label)
-                               || (tree.tparams.length > maxTparamsToSpecialize)) => {
+                               || (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.length}")
 
-        def specialize(instatiations: collection.mutable.ListBuffer[Type], names: collection.mutable.ArrayBuffer[String]): Tree = {
+        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 => {
@@ -58,29 +72,25 @@ class TypeSpecializer extends MiniPhaseTransform {
           })
         }
 
-        def generateSpecializations(remainingTParams: List[TypeDef])
-                                  (instatiated: ArrayBuffer[TypeDef], instatiations: ListBuffer[Type],
-                                    names: ArrayBuffer[String]): Iterable[Tree] = {
+        def generateSpecializations(remainingTParams: List[TypeDef], remainingBounds: List[TypeBounds])
+                                  (instatiations: List[Type],
+                                    names: List[String]): Iterable[Tree] = {
           if (remainingTParams.nonEmpty) {
             val typeToSpecialize = remainingTParams.head
-            specialisedTypes.flatMap { tpnme =>
+            val bounds = remainingBounds.head
+            specialisedTypes.filter{ tpnme =>
+              bounds.contains(tpnme._1)
+            }.flatMap { tpnme =>
               val tpe = tpnme._1
               val nme = tpnme._2
-              instatiated.+=(typeToSpecialize)
-              instatiations.+=(tpe)
-              names.+=(nme)
-              val r = generateSpecializations(remainingTParams.tail)(instatiated, instatiations, names)
-              instatiated.drop(1)
-              instatiations.drop(1)
-              names.drop(1)
-              r
+              generateSpecializations(remainingTParams.tail, remainingBounds.tail)(tpe :: instatiations, nme :: names)
             }
           } else
-            List(specialize(instatiations, names))
+            List(specialize(instatiations.reverse, names.reverse))
         }
 
 
-        Thicket(tree :: generateSpecializations(tree.tparams)(ArrayBuffer.empty, ListBuffer.empty, ArrayBuffer.empty).toList)
+        Thicket(tree :: generateSpecializations(tree.tparams, poly.paramBounds)(List.empty, List.empty).toList)
       }
       case _ => tree
     }

test/dotc/tests.scala

@@ -143,48 +143,4 @@ class tests extends CompilerTest {
 
 
   @Test def dotty = compileDir(dottyDir, "tools", "-deep" :: allowDeepSubtypes ++ twice) // note the -deep argument
-
-
-  @Test def dotc_ast = compileDir(dotcDir, "ast")
-  @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
-
-// This directory doesn't exist anymore
-//  @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_parsing = compileDir(dotcDir, "parsing") // twice omitted to make tests run faster
-
-  @Test def dotc_printing = compileDir(dotcDir, "printing") // twice omitted to make tests run faster
-
-  @Test def dotc_reporting = compileDir(dotcDir, "reporting") // twice omitted to make tests run faster
-
-  @Test def dotc_typer = compileDir(dotcDir, "typer")// twice omitted to make tests run faster
-    // error: error while loading Checking$$anon$2$,
-    // class file 'target/scala-2.11/dotty_2.11-0.1-SNAPSHOT.jar(dotty/tools/dotc/typer/Checking$$anon$2.class)'
-    // has location not matching its contents: contains class $anon
-
-  @Test def dotc_util = compileDir(dotcDir, "util") // twice omitted to make tests run faster
-
-  @Test def tools_io = compileDir(toolsDir, "io") // inner class has symbol <none>
-
-  @Test def helloWorld = compileFile(posDir, "HelloWorld")
-  @Test def labels = compileFile(posDir, "Labels", twice)
-  //@Test def tools = compileDir(dottyDir, "tools", "-deep" :: Nil)(allowDeepSubtypes)
-
-  @Test def testNonCyclic = compileList("testNonCyclic", List(
-      dotcDir + "CompilationUnit.scala",
-      coreDir + "Types.scala",
-      dotcDir + "ast/Trees.scala"
-    ), List("-Xprompt") ++ staleSymbolError ++ twice)
-
-  @Test def testIssue_34 = compileList("testIssue_34", List(
-      dotcDir + "config/Properties.scala",
-      dotcDir + "config/PathResolver.scala"
-    ), List(/* "-Ylog:frontend", */ "-Xprompt") ++ staleSymbolError ++ twice)
-
-  val javaDir = "./tests/pos/java-interop/"
-  @Test def java_all = compileFiles(javaDir, twice)
-  //@Test def dotc_compilercommand = compileFile(dotcDir + "config/", "CompilerCommand")
 }