Work in progress

3 failing tests left:

tests/run/t8933c.scala
tests/pos/t348plus.scala
dotty1 from idempotency1

Author: OlivierBlanvillain

compiler/src/dotty/tools/dotc/Compiler.scala

@@ -88,9 +88,10 @@ class Compiler {
            new NonLocalReturns,     // Expand non-local returns
            new CapturedVars,        // Represent vars captured by closures as heap objects
            new Constructors,        // Collect initialization code in primary constructors
-                                       // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
+                                   // Note: constructors changes decls in transformTemplate, no InfoTransformers should be added after it
            new FunctionalInterfaces, // Rewrites closures to implement @specialized types of Functions.
-           new GetClass),           // Rewrites getClass calls on primitive types.
+           new GetClass,             // Rewrites getClass calls on primitive types.
+           new Simplify),            // Perform local optimizations, simplified versions of what linker does.
       List(new LambdaLift,          // Lifts out nested functions to class scope, storing free variables in environments
                                        // Note: in this mini-phase block scopes are incorrect. No phases that rely on scopes should be here
            new ElimStaticThis,      // Replace `this` references to static objects by global identifiers

compiler/src/dotty/tools/dotc/config/Printers.scala

@@ -32,4 +32,5 @@ object Printers {
   val pickling: Printer = noPrinter
   val inlining: Printer = noPrinter
   val exhaustivity: Printer = noPrinter
+  val simplify: Printer = noPrinter
 }

compiler/src/dotty/tools/dotc/core/Scopes.scala

@@ -91,8 +91,10 @@ object Scopes {
     /** Is the scope empty? */
     def isEmpty: Boolean = lastEntry eq null
 
-    def foreach[U](p: Symbol => U)(implicit ctx: Context): Unit = toList foreach p
+    /** Applies a function f to all Symbols of this Scope. */
+    def foreach[U](f: Symbol => U)(implicit ctx: Context): Unit = toList.foreach(f)
 
+    /** Selects all Symbols of this Scope which satisfy a predicate. */
     def filter(p: Symbol => Boolean)(implicit ctx: Context): List[Symbol] = {
       ensureComplete()
       var syms: List[Symbol] = Nil
@@ -105,6 +107,10 @@ object Scopes {
       syms
     }
 
+    /** Tests whether a predicate holds for at least one Symbol of this Scope. */
+    def exists(p: Symbol => Boolean)(implicit ctx: Context): Boolean = filter(p).isEmpty
+
+    /** Finds the first Symbol of this Scope satisfying a predicate, if any. */
     def find(p: Symbol => Boolean)(implicit ctx: Context): Symbol = filter(p) match {
       case sym :: _ => sym
       case _ => NoSymbol

compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala

@@ -68,8 +68,8 @@ class tests extends CompilerTest {
   }
 
   implicit val defaultOptions: List[String] = noCheckOptions ++ {
-    if (dotty.Properties.isRunByDrone) List("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef") // should be Ycheck:all, but #725
-    else List("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef")
+    if (dotty.Properties.isRunByDrone) List("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef,simplify") // should be Ycheck:all, but #725
+    else List("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef,simplify")
   } ++ checkOptions ++ classPath
 
   val testPickling = List("-Xprint-types", "-Ytest-pickler", "-Ystop-after:pickler", "-Yprintpos")

compiler/test/dotc/tests.scala

@@ -32,15 +32,15 @@ class CompilationTests extends ParallelTesting {
     compileDir("../collection-strawman/src/main", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/ast", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/config", defaultOptions) +
-    compileDir("../compiler/src/dotty/tools/dotc/core", allowDeepSubtypes) +
+    compileDir("../compiler/src/dotty/tools/dotc/core", allowDeepSubtypes)
     compileDir("../compiler/src/dotty/tools/dotc/transform", allowDeepSubtypes) +
     compileDir("../compiler/src/dotty/tools/dotc/parsing", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/printing", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/reporting", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/typer", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/dotc/util", defaultOptions) +
     compileDir("../compiler/src/dotty/tools/io", defaultOptions) +
-    compileDir("../compiler/src/dotty/tools/dotc/core", noCheckOptions ++ classPath) +
+    compileDir("../compiler/src/dotty/tools/dotc/core", noCheckOptions ++ classPath)
     compileFile("../tests/pos/nullarify.scala", defaultOptions.and("-Ycheck:nullarify")) +
     compileFile("../tests/pos-scala2/rewrites.scala", scala2Mode.and("-rewrite")).copyToTarget() +
     compileFile("../tests/pos-special/t8146a.scala", allowDeepSubtypes) +

compiler/test/dotty/tools/dotc/CompilationTests.scala

@@ -50,7 +50,7 @@ object TestConfiguration {
     Array("-classpath", paths)
   }
 
-  private val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef")
+  private val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,mixin,arrayConstructors,labelDef")
 
   val defaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath :+ "-optimise"
   val allowDeepSubtypes = defaultOptions diff Array("-Yno-deep-subtypes")

compiler/test/dotty/tools/vulpix/TestConfiguration.scala

@@ -0,0 +1,71 @@
+trait T {
+  def apply(a1: String, a2: String, a3: String): String = a3
+}
+
+object Test {
+  def test1 =
+    ??? // Nothing.String.CharSequence.String.CharSequence.String
+      .toString.subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test2 =
+    (new T {})
+      .apply(???, "b", "c")
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test3 =
+    (new T {})
+      .apply("a", ???, "c")
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test4 =
+    (new T {})
+      .apply("a", "b", ???)
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test5 =
+    (new T {})
+      .apply("a", "b", ???)
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test6 =
+    (if (???) "a" else "b")
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test7 =
+    { ???; "b"; "c" }
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test8 =
+    { "a"; ???; "c" }
+      .subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  def test9 =
+    { "a"; "b"; ??? }
+      .toString.subSequence(0, 1).toString.subSequence(0, 1).toString
+
+  // run -optimise -Xprint:simplify
+  // def test1(): String = ???(): String
+  // def test2(): String = ???(): String
+  // def test3(): String = ???(): String
+  // def test4(): String = ???(): String
+  // def test5(): String = ???(): String
+  // def test6(): String = ???(): String
+  // def test7(): String = ???(): String
+  // def test8(): String = ???(): String
+  // def test9(): String = ???(): String
+
+  def test10: Unit = {
+    def fail = throw new IllegalArgumentException("")
+  }
+
+  def test11: Unit = {
+    trait Context
+    trait Type
+    trait Tree {
+      def withType(tpe: Type)(implicit ctx: Context): Tree = this
+    }
+
+    def readTree()(implicit ctx: Context): Any =
+      (new Tree {}).withType(???)(ctx).withType(???)
+  }
+}

tests/pos/bubbleUpNothing.scala

@@ -0,0 +1,34 @@
+object Test {
+  def test0: Unit = {
+    trait I {
+      def foo: Any = null
+    }
+    val s: I = null
+    s.foo
+  }
+
+  def test1: Unit = {
+    // `s1` is used once as a value, several times as a type. This tests shows
+    // that Ycheck is happy despite devalify inlining (and removing) `s1`.
+    val s1: String = "singleton"
+    val s2: s1.type = s1
+
+    val t: Option[s1.type] = None
+
+    println(t)
+    println((s2: s1.type))
+  }
+
+  def test2: Unit = {
+    class Foo {
+      class Bar
+    }
+
+    val foo = new Foo
+    val subFoo = foo
+    // Inlining `subFoo` changes the type of `subFooBar` from `subFoo.Bar` to `foo.Bar`
+    val subFooBar = new subFoo.Bar
+
+    println(subFooBar)
+  }
+}