Add PreSpecializer phase

AlexSikia · AlexSikia · commit c95aff24fc90 · 2015-06-03T03:42:42.000+02:00
Creates a new `PreSpecializer` phase that detects `@specialized`
annotations and registers them. This is necessary because annotations
are lost further down the pipeline (and before TypeSpecializer runs.)
diff --git a/src/dotty/tools/dotc/Compiler.scala b/src/dotty/tools/dotc/Compiler.scala
@@ -38,10 +38,13 @@ class Compiler {
   def phases: List[List[Phase]] =
     List(
       List(new FrontEnd),
-      List(new PostTyper),
-      List(new Pickler),
-      List(new FirstTransform),
-      List(new RefChecks,
+      List(new InstChecks),
+      List(new FirstTransform,
+           new SyntheticMethods),
+      List(new SuperAccessors),
+      List(new Pickler), // Pickler needs to come last in a group since it should not pickle trees generated later
+      List(new PreSpecializer,
+           new RefChecks,
            new ElimRepeated,
            new NormalizeFlags,
            new ExtensionMethods,
diff --git a/src/dotty/tools/dotc/config/ScalaSettings.scala b/src/dotty/tools/dotc/config/ScalaSettings.scala
@@ -152,7 +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","all","Specialize all methods.", "all") // TODO remove default value
+  val Yspecialize = StringSetting("-Yspecialize","","Specialize all methods.", "")
 
   def stop = YstopAfter
 
diff --git a/src/dotty/tools/dotc/core/Phases.scala b/src/dotty/tools/dotc/core/Phases.scala
@@ -240,6 +240,7 @@ object Phases {
     private val explicitOuterCache = new PhaseCache(classOf[ExplicitOuter])
     private val gettersCache = new PhaseCache(classOf[Getters])
     private val genBCodeCache = new PhaseCache(classOf[GenBCode])
+    private val specializeCache = new PhaseCache(classOf[TypeSpecializer])
 
     def typerPhase = typerCache.phase
     def refchecksPhase = refChecksCache.phase
@@ -251,6 +252,7 @@ object Phases {
     def explicitOuterPhase = explicitOuterCache.phase
     def gettersPhase = gettersCache.phase
     def genBCodePhase = genBCodeCache.phase
+    def specializePhase = specializeCache.phase
 
     def isAfterTyper(phase: Phase): Boolean = phase.id > typerPhase.id
   }
diff --git a/src/dotty/tools/dotc/transform/PreSpecializer.scala b/src/dotty/tools/dotc/transform/PreSpecializer.scala
@@ -0,0 +1,98 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.ast.Trees.{Select, Ident, SeqLiteral, Typed}
+import dotty.tools.dotc.ast.tpd
+import dotty.tools.dotc.core.Annotations.Annotation
+import dotty.tools.dotc.core.Contexts.Context
+import dotty.tools.dotc.core.DenotTransformers.InfoTransformer
+import dotty.tools.dotc.core.StdNames._
+import dotty.tools.dotc.core.{Flags, Definitions, Symbols}
+import dotty.tools.dotc.core.Symbols.Symbol
+import dotty.tools.dotc.core.Types.{TermRef, TypeRef, OrType, Type}
+import dotty.tools.dotc.transform.TreeTransforms.{TransformerInfo, MiniPhaseTransform}
+
+import scala.collection.mutable
+
+/**
+ * This phase runs before {what phase ?}, so as to retrieve all `@specialized`
+ * anotations before they are thrown away, and stores them through a `PhaseCache`
+ * for the `TypeSpecializer` phase.
+ */
+class PreSpecializer extends MiniPhaseTransform with InfoTransformer {
+
+  override def phaseName: String = "prespecialize"
+
+  private val specTypes: mutable.HashMap[Symbols.Symbol, List[Type]] = mutable.HashMap.empty
+
+  override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = {
+
+    def getSpecTypes(sym: Symbol)(implicit ctx: Context): List[Type] = {
+
+      def allowedToSpecialize(sym: Symbol): Boolean = {
+        sym.name != nme.asInstanceOf_ &&
+          !(sym is Flags.JavaDefined) &&
+          !sym.isConstructor//isPrimaryConstructor
+      }
+
+      if (allowedToSpecialize(sym)) {
+        val annotation = sym.denot.getAnnotation(ctx.definitions.specializedAnnot).getOrElse(Nil)
+        annotation match {
+          case annot: Annotation =>
+            val args = annot.arguments
+            if (args.isEmpty) primitiveTypes
+            else args.head match {
+              case a@Typed(SeqLiteral(types), _) => types.map(t => nameToType(t.tpe))
+              case a@Select(Ident(_), _) => {
+                println(a)
+                primitiveTypes
+              }
+              case _ => {
+                println("Nonono")
+                ctx.error("surprising match on specialized annotation"); Nil
+              }
+            }
+          case nil => Nil
+        }
+      } else Nil
+    }
+    val st = getSpecTypes(sym)
+    if (st.nonEmpty) {
+      specTypes.put(sym, st)
+    }
+    tp
+  }
+
+  private final def nameToType(name: Type)(implicit ctx: Context) =
+    name.asInstanceOf[TermRef].name.toString match {
+            case s if s.startsWith("Int")     => defn.IntType
+            case s if s.startsWith("Boolean") => defn.BooleanType
+            case s if s.startsWith("Byte")    => defn.ByteType
+            case s if s.startsWith("Long")    => defn.LongType
+            case s if s.startsWith("Short")   => defn.ShortType
+            case s if s.startsWith("Float")   => defn.FloatType
+            case s if s.startsWith("Unit")    => defn.UnitType
+            case s if s.startsWith("Double")  => defn.DoubleType
+            case s if s.startsWith("Char")    => defn.CharType
+  }
+
+  def defn(implicit ctx: Context): Definitions = ctx.definitions
+
+  private def primitiveTypes(implicit ctx: Context) =
+    List(ctx.definitions.ByteType,
+      ctx.definitions.BooleanType,
+      ctx.definitions.ShortType,
+      ctx.definitions.IntType,
+      ctx.definitions.LongType,
+      ctx.definitions.FloatType,
+      ctx.definitions.DoubleType,
+      ctx.definitions.CharType,
+      ctx.definitions.UnitType
+    )
+
+  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+    specTypes.keys.foreach(
+      sym => ctx.specializePhase.asInstanceOf[TypeSpecializer].registerSpecializationRequest(tree.symbol)(specTypes(sym))
+    )
+    tree
+  }
+}
diff --git a/src/dotty/tools/dotc/transform/TypeSpecializer.scala b/src/dotty/tools/dotc/transform/TypeSpecializer.scala
@@ -20,17 +20,6 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
 
   final val maxTparamsToSpecialize = 2
 
-  private final def nameToSpecialisedType(implicit ctx: Context) =
-    Map("Byte" -> ctx.definitions.ByteType,
-      "Boolean" -> ctx.definitions.BooleanType,
-      "Short" -> ctx.definitions.ShortType,
-      "Int" -> ctx.definitions.IntType,
-      "Long" -> ctx.definitions.LongType,
-      "Float" -> ctx.definitions.FloatType,
-      "Double" -> ctx.definitions.DoubleType,
-      "Char" -> ctx.definitions.CharType,
-      "Unit" -> ctx.definitions.UnitType)
-
   private final def specialisedTypeToSuffix(implicit ctx: Context) =
     Map(ctx.definitions.ByteType -> "$mcB$sp",
       ctx.definitions.BooleanType -> "$mcZ$sp",
@@ -54,7 +43,7 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
       ctx.definitions.UnitType
     )
 
-  private val specializationRequests: mutable.HashMap[Symbols.Symbol, List[List[Type]]] = mutable.HashMap.empty
+  private val specializationRequests: mutable.HashMap[Symbols.Symbol, List[Type]] = mutable.HashMap.empty
 
   /**
    *  A map that links symbols to their specialized variants.
@@ -63,14 +52,12 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
   private val newSymbolMap: mutable.HashMap[Symbol, mutable.HashMap[List[Type], Symbols.Symbol]] = mutable.HashMap.empty
 
   override def transformInfo(tp: Type, sym: Symbol)(implicit ctx: Context): Type = {
-
-    def generateSpecializations(remainingTParams: List[Name], remainingBounds: List[TypeBounds], specTypes: List[Type])
+    def generateSpecializations(remainingTParams: List[Name], specTypes: List[Type])
                                (instantiations: List[Type], names: List[String], poly: PolyType, decl: Symbol)
                                (implicit ctx: Context): List[Symbol] = {
       if (remainingTParams.nonEmpty) {
-        val bounds = remainingBounds.head
         val specializations = (for (tpe <- specTypes) yield {
-          generateSpecializations(remainingTParams.tail, remainingBounds.tail, specTypes)(tpe :: instantiations, specialisedTypeToSuffix(ctx)(tpe) :: names, poly, decl)
+          generateSpecializations(remainingTParams.tail, specTypes)(tpe :: instantiations, specialisedTypeToSuffix(ctx)(tpe) :: names, poly, decl)
         }).flatten
         specializations
       }
@@ -96,12 +83,15 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
       sym.info match {
         case classInfo: ClassInfo =>
           val newDecls = classInfo.decls.filterNot(_.isConstructor/*isPrimaryConstructor*/).flatMap(decl => {
+            if(decl.name.toString.contains("foobar")) {
+              println("hello")
+            }
             if (shouldSpecialize(decl)) {
               decl.info.widen match {
                 case poly: PolyType =>
                   if (poly.paramNames.length <= maxTparamsToSpecialize && poly.paramNames.length > 0) {
-                    val specTypes = getSpecTypes(sym)
-                    generateSpecializations(poly.paramNames, poly.paramBounds, specTypes)(List.empty, List.empty, poly, decl)
+                    val specTypes = getSpecTypes(decl).filter(tpe => poly.paramBounds.forall(_.contains(tpe)))
+                    generateSpecializations(poly.paramNames, specTypes)(List.empty, List.empty, poly, decl)
                   }
                   else Nil
                 case nil => Nil
@@ -120,16 +110,11 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
   }
 
   def getSpecTypes(sym: Symbol)(implicit ctx: Context): List[Type] = {
-    sym.denot.getAnnotation(ctx.definitions.specializedAnnot).getOrElse(Nil) match {
-      case annot: Annotation =>
-        annot.arguments match {
-          case List(SeqLiteral(types)) =>
-            types.map(tpeTree => nameToSpecialisedType(ctx)(tpeTree.tpe.asInstanceOf[TermRef].name.toString()))
-          case List() => primitiveTypes
-        }
-      case nil =>
-        if(ctx.settings.Yspecialize.value == "all") primitiveTypes
-        else Nil
+    val requested = specializationRequests.getOrElse(sym, List())
+    if (requested.nonEmpty) requested.toList
+    else {
+      if(ctx.settings.Yspecialize.value == "all") primitiveTypes
+      else Nil
     }
   }
 
@@ -142,35 +127,8 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
     if(ctx.phaseId > this.treeTransformPhase.id)
       assert(ctx.phaseId <= this.treeTransformPhase.id)
     val prev = specializationRequests.getOrElse(method, List.empty)
-    specializationRequests.put(method, arguments :: prev)
+    specializationRequests.put(method, arguments ::: prev)
   }
-/*
-  def specializeForAll(sym: Symbols.Symbol)(implicit ctx: Context): List[Type] = {
-    registerSpecializationRequest(sym)(primitiveTypes)
-    println(s"Specializing $sym for all primitive types")
-    specializationRequests.getOrElse(sym, Nil).flatten
-  }
-
-  def specializeForSome(sym: Symbols.Symbol)(annotationArgs: List[Type])(implicit ctx: Context): List[Type] = {
-    registerSpecializationRequest(sym)(annotationArgs)
-    println(s"specializationRequests : $specializationRequests")
-    specializationRequests.getOrElse(sym, Nil).flatten
-  }
-
-  def specializeFor(sym: Symbols.Symbol)(implicit ctx: Context): List[Type] = {
-    sym.denot.getAnnotation(ctx.definitions.specializedAnnot).getOrElse(Nil) match {
-      case annot: Annotation =>
-        annot.arguments match {
-          case List(SeqLiteral(types)) =>
-            specializeForSome(sym)(types.map(tpeTree =>
-              nameToSpecialisedType(ctx)(tpeTree.tpe.asInstanceOf[TermRef].name.toString()))) // Not sure how to match TermRefs rather than type names
-          case List() => specializeForAll(sym)
-        }
-      case nil =>
-        if(ctx.settings.Yspecialize.value == "all") specializeForAll(sym)
-        else Nil
-    }
-  }*/
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
 
@@ -228,7 +186,7 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
       assert(betterDefs.length < 2) // TODO: How to select the best if there are several ?
 
       if (betterDefs.nonEmpty) {
-        println(s"method $fun rewired to specialozed variant with type (${betterDefs.head._1})")
+        println(s"method $fun rewired to specialized variant with type (${betterDefs.head._1})")
         val prefix = fun match {
           case Select(pre, name) =>
             pre
diff --git a/test/dotc/tests.scala b/test/dotc/tests.scala
@@ -249,4 +249,11 @@ class tests extends CompilerTest {
   @Test def mini_more = compileFiles(miniMoreDir)//, List("-Xprint:all"))
   //@Test def pos_all = compileFiles(posDir)//, List("-Xprint:all"))
 
+  @Test def pos_mutual_spec = compileFile(posDir, "mutual_specialization", List("-Xprint:all"))
+  //@Test def pos_mutual_spec = compileFile(posDir, "mutual_specialization")
+  //@Test def pos_spec = compileFile(posDir, "specialization")
+*/
+  @Test def pos_return_spec = compileFile(posDir, "return_specialization")
+//  @Test def pos_si7638 = compileFile(posDir, "SI-7638", List("-Xprint:all"))
+
 }
diff --git a/tests/pos/mutual_specialization.scala b/tests/pos/mutual_specialization.scala
@@ -0,0 +1,10 @@
+object mutual_specialization {
+  class A[T] {
+    def foo[T](b: B[T], n: Int): Unit = if (n > 0) b.bar(this, n-1)
+  }
+  class B[T] {
+    def bar[T](a: A[T], n: Int): Unit = if (n > 0) a.foo(this, n-1)
+  }
+  def foobar[@specialized(Int, Float, Double) T](n: T): Unit = new A[T].foo(new B[T], 5)
+  foobar(5)
+}
diff --git a/tests/pos/return_specialization.scala b/tests/pos/return_specialization.scala
@@ -0,0 +1,6 @@
+object return_specialization {
+  def qwa[@specialized T](a: (String, String) => T, b: T): T = {
+      if(a ne this) return a("1", "2")
+      else b
+  }
+}
