Add run test for specialisation

Adds a simple run test which checks for an expected number of generated
specialised methods, and correct parameter types instantiation.

Author: AlexSikia

src/dotty/tools/dotc/Compiler.scala

@@ -20,21 +20,21 @@ import dotty.tools.backend.jvm.{LabelDefs, GenBCode}
 class Compiler {
 
   /** Meta-ordering constraint:
-    *
-    *  DenotTransformers that change the signature of  their denotation's info must go
-    *  after erasure. The reason is that denotations are permanently referred to by
-    *  TermRefs which contain a signature. If the signature of a symbol would change,
-    *  all refs to it would become outdated - they could not be dereferenced in the
-    *  new phase.
-    *
-    *  After erasure, signature changing denot-transformers are OK because erasure
-    *  will make sure that only term refs with fixed SymDenotations survive beyond it. This
-    *  is possible because:
-    *
-    *   - splitter has run, so every ident or select refers to a unique symbol
-    *   - after erasure, asSeenFrom is the identity, so every reference has a
-    *     plain SymDenotation, as opposed to a UniqueRefDenotation.
-    */
+   *
+   *  DenotTransformers that change the signature of  their denotation's info must go
+   *  after erasure. The reason is that denotations are permanently referred to by
+   *  TermRefs which contain a signature. If the signature of a symbol would change,
+   *  all refs to it would become outdated - they could not be dereferenced in the
+   *  new phase.
+   *
+   *  After erasure, signature changing denot-transformers are OK because erasure
+   *  will make sure that only term refs with fixed SymDenotations survive beyond it. This
+   *  is possible because:
+   *
+   *   - splitter has run, so every ident or select refers to a unique symbol
+   *   - after erasure, asSeenFrom is the identity, so every reference has a
+   *     plain SymDenotation, as opposed to a UniqueRefDenotation.
+   */
   def phases: List[List[Phase]] =
     List(
       List(new FrontEnd),
@@ -87,13 +87,13 @@ class Compiler {
   }
 
   /** Produces the following contexts, from outermost to innermost
-    *
-    *    bootStrap:   A context with next available runId and a scope consisting of
-    *                 the RootPackage _root_
-    *    start        A context with RootClass as owner and the necessary initializations
-    *                 for type checking.
-    *    imports      For each element of RootImports, an import context
-    */
+   *
+   *    bootStrap:   A context with next available runId and a scope consisting of
+   *                 the RootPackage _root_
+   *    start        A context with RootClass as owner and the necessary initializations
+   *                 for type checking.
+   *    imports      For each element of RootImports, an import context
+   */
   def rootContext(implicit ctx: Context): Context = {
     ctx.definitions.init(ctx)
     ctx.setPhasePlan(phases)

test/dotc/tests.scala

@@ -9,20 +9,19 @@ import org.junit.experimental.categories._
 class tests extends CompilerTest {
 
   val noCheckOptions = List(
-    //        "-verbose",
-    //         "-Ylog:frontend",
-    //        "-Xprompt",
-    //        "-explaintypes",
-    //        "-Yshow-suppressed-errors",
+//        "-verbose",
+//         "-Ylog:frontend",
+//        "-Xprompt",
+//        "-explaintypes",
+//        "-Yshow-suppressed-errors",
   )
 
   val defaultOutputDir = "./out/"
 
   implicit val defaultOptions = noCheckOptions ++ List(
-
-    "-Yno-deep-subtypes", "-Yno-double-bindings",
-    "-Ycheck:tailrec,resolveSuper,mixin,restoreScopes",
-    "-d", defaultOutputDir
+     "-Yno-deep-subtypes", "-Yno-double-bindings",
+     "-Ycheck:tailrec,resolveSuper,mixin,restoreScopes",
+     "-d", defaultOutputDir
   )
   val testPickling = List("-Xprint-types", "-Ytest-pickler", "-Ystop-after:pickler")
 
@@ -51,11 +50,10 @@ 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)
+// This directory doesn't exist anymore
+// @Test def pickle_pickling = compileDir(coreDir, "pickling", testPickling)
   @Test def pickle_ast = compileDir(dotcDir, "ast", testPickling)
 
   //@Test def pickle_core = compileDir(dotcDir, "core", testPickling, xerrors = 2) // two spurious comparison errors in Types and TypeOps
@@ -95,7 +93,6 @@ class tests extends CompilerTest {
   @Test def pos_packageObj = compileFile(posDir, "i0239", twice)
   @Test def pos_anonClassSubtyping = compileFile(posDir, "anonClassSubtyping", twice)
   @Test def pos_extmethods = compileFile(posDir, "extmethods", twice)
-  //@Test def pos_specialization = compileFile(posDir, "specialization")
 
   @Test def pos_all = compileFiles(posDir) // twice omitted to make tests run faster
 
@@ -148,8 +145,8 @@ class tests extends CompilerTest {
   @Test def neg_instantiateAbstract = compileFile(negDir, "instantiateAbstract", xerrors = 8)
   @Test def neg_selfInheritance = compileFile(negDir, "selfInheritance", xerrors = 5)
 
-  //@Test def run_all = runFiles(runDir)
-  //@Test def run_spec = runFile(runDir, "specialization")
+
+  @Test def run_all = runFiles(runDir)
 
 
   @Test def dotty = compileDir(dottyDir, "tools", "-deep" :: allowDeepSubtypes ++ twice) // note the -deep argument
@@ -159,8 +156,8 @@ 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
 
-  // This directory doesn't exist anymore
-  //  @Test def dotc_core_pickling = compileDir(coreDir, "pickling")(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
 
@@ -171,9 +168,9 @@ class tests extends CompilerTest {
   @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
+ // 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
 
@@ -184,19 +181,19 @@ class tests extends CompilerTest {
   //@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)
+     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)
+     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 specialization = compileFile(specialDir, "specialization", List("-Xprint:specialize"))
   @Test def mutual_spec = compileFile(specialDir, "mutual_specialization", List("-Xprint:specialize"))
   @Test def return_spec = compileFile(specialDir, "return_specialization", List("-Xprint:specialize"))
@@ -209,12 +206,7 @@ class tests extends CompilerTest {
   @Test def pos_this_specialization = compileFile(specialDir, "this_specialization", List("-Xprint:specialize"))
   @Test def pos_spec_all = compileFiles(specialDir)
 
-
-  //@Test def mini_method = compileFiles(miniMethodDir)//, List("-Xprint:all"))
-  //@Test def mini_more = compileFiles(miniMoreDir)//, List("-Xprint:all"))
-  //@Test def pos_all = compileFiles(posDir)//, List("-Xprint:all"))
-
-  //@Test def pos_si7638 = compileFile(posDir, "SI-7638", List("-Xprint:all"))
-  //@Test def test = compileFile(posDir, "t247", List("-Xprint:all"))
+  @Test def run_spec = runFile(runDir, "specialization")
+  
   //@Test def dotc_compilercommand = compileFile(dotcDir + "config/", "CompilerCommand")
-}
+}

tests/run/specialization.check

@@ -0,0 +1,6 @@
+10
+82
+3
+int
+int,double
+double,int

tests/run/specialization.scala

@@ -0,0 +1,41 @@
+object Test extends dotty.runtime.LegacyApp {
+
+  class Foo {
+    def foo[@specialized U](u: U) = u
+  }
+  class Bar {
+    def bar[@specialized U, V](u: U, v: V) = v
+  }
+  class Baz {
+    def baz[@specialized(Int, Char) V](v: V): V = v
+  }
+
+  override def main(args: Array[String]): Unit = {
+    /**
+     * Expected output is:
+     *
+     * 10
+     * 82
+     * 3
+     * int
+     * double,int
+     * int,double
+     */
+
+    val a = new Foo
+    val b = new Bar
+    val c = new Baz
+    val foo_methods = a.getClass.getMethods
+    val bar_methods = b.getClass.getMethods
+    val baz_methods = c.getClass.getMethods
+    println(foo_methods.filter(_.toString.contains("foo")).length)
+    println(bar_methods.filter(_.toString.contains("bar")).length)
+    println(baz_methods.filter(_.toString.contains("baz")).length)
+
+    val baz_int_param = baz_methods.filter(_.toString.contains("$mcI$sp")).head.getParameterTypes.mkString(",")
+    val bar_int_double_params = bar_methods.filter(s => s.toString.contains("$mcDI$sp") || s.toString.contains("$mcID$sp"))
+    println(baz_int_param)
+    println(bar_int_double_params.head.getParameterTypes.mkString(","))
+    println(bar_int_double_params.tail.head.getParameterTypes.mkString(","))
+  }
+}