Adapt specialization tests and clean up

Author: AlexSikia

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

@@ -19,7 +19,7 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
   import tpd._
   override def phaseName = "specialize"
 
-  final val maxTparamsToSpecialize = 2
+  final var maxTparamsToSpecialize = 0
 
   private final def specialisedTypeToSuffix(implicit ctx: Context) =
     Map(defn.ByteType -> "B",
@@ -56,7 +56,7 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
   private val newSymbolMap: mutable.HashMap[Symbol, mutable.HashMap[List[Type], Symbols.Symbol]] = mutable.HashMap.empty
 
   def allowedToSpecialize(sym: Symbol, numOfTypes: Int)(implicit ctx: Context): Boolean = {
-    numOfTypes <= maxTparamsToSpecialize &&
+    (maxTparamsToSpecialize == 0 || numOfTypes <= maxTparamsToSpecialize) &&
       numOfTypes > 0 &&
       sym.name != nme.asInstanceOf_ &&
       sym.name != nme.isInstanceOf_ &&
@@ -179,14 +179,12 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
               polyDefDef(newSym.asTerm, { tparams => vparams => {
                 val tmap: (Tree => Tree) = _ match {
                   case Return(t, from) if from.symbol == tree.symbol => Return(t, ref(newSym))
-                  case t: TypeApply => {
+                  case t: TypeApply =>
                     (origTParams zip instantiations(index)).foreach(x => genericToInstantiation.put(x._1, x._2))
                     transformTypeApply(t)
-                  }
-                  case t: Apply => {
+                  case t: Apply =>
                     (origTParams zip instantiations(index)).foreach(x => genericToInstantiation.put(x._1, x._2))
                     transformApply(t)
-                  }
                   case t => t
                 }
 
@@ -204,7 +202,7 @@ class TypeSpecializer extends MiniPhaseTransform  with InfoTransformer {
                   override def transform(tree1: Tree)(implicit ctx: Context) = super.transform(tree1) match {
                     case t @ Apply(fun, args) =>
                       assert(sameLength(args, fun.tpe.widen.firstParamTypes))
-                      val newArgs = (args zip fun.tpe.widen.firstParamTypes).map{case(t, tpe) => t.ensureConforms(tpe)}
+                      val newArgs = (args zip fun.tpe.widen.firstParamTypes).map{case(tr, tpe) => tr.ensureConforms(tpe)}
                       if (sameTypes(args, newArgs)) {
                         t
                       } else tpd.Apply(fun, newArgs)

test/dotc/tests.scala

@@ -203,9 +203,11 @@ class tests extends CompilerTest {
   @Test def bounds_spec = compileFile(specialDir, "bounds_specialization")
   @Test def multi_spec = compileFile(specialDir, "multi_specialization")
   @Test def pos_this_specialization = compileFile(specialDir, "this_specialization")
-  @Test def pos_spec_all = compileFiles(specialDir)
+  @Test def specializable_spec = runFile(specialDir, "specializable_specialization")
+  @Test def anyRef_spec = runFile(specialDir, "anyRef_specialization")
+  @Test def recursive_spec = runFile(specialDir, "recursive_specialization")
 
   @Test def run_spec = runFile(runDir, "method-specialization")
-  
+
   //@Test def dotc_compilercommand = compileFile(dotcDir + "config/", "CompilerCommand")
 }

tests/pos/specialization/anyRef_specialization.scala

@@ -0,0 +1,3 @@
+object Test {
+  def foo[@specialized(AnyRef) T](t: T): T = t
+}

tests/pos/specialization/mutual_specialization.scala

@@ -1,10 +1,8 @@
 object mutual_specialization {
   class A[T] {
-    def foo[T](b: B[T], n: Int): Unit = if (n > 0) b.bar(this, n-1)
+    def foo[@specialized U](b: U, n: Int): Unit = if (n > 0) bar(b, n-1)
+    def bar[@specialized V](a: V, n: Int): Unit = if (n > 0) foo(a, 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)
+  def foobar[@specialized(Char) X](n: X): Unit = new A[X].foo(2, 5)
   foobar(5)
 }

tests/pos/specialization/recursive_specialization.scala

@@ -0,0 +1,7 @@
+class Spec {
+  def plus[@specialized T](a: T, b:T)(ev: Numeric[T]): T = plus(b, a)(ev)
+}
+
+class IntSpec extends Spec {
+  val res = plus(1,2)(Numeric.IntIsIntegral)
+}

tests/pos/specialization/specializable_specialization.scala

@@ -0,0 +1,10 @@
+import Specializable._
+
+object specializable {
+  def foo[@specialized(Primitives) T](t: T): T = t
+  def foo2[@specialized(Everything) T](t: T): T = t
+  def foo3[@specialized(Bits32AndUp) T](t: T): T = t
+  def foo4[@specialized(Integral) T](t: T): T = t
+  def foo5[@specialized(AllNumeric) T](t: T): T = t
+  def foo6[@specialized(BestOfBreed) T](t: T): T = t
+}