Finish rebase over dotty upstream

Author: DarkDimius

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

@@ -7,16 +7,16 @@ import Periods._
 import Symbols._
 import Types._
 import Scopes._
-import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
-import reporting.{Reporter, ConsoleReporter}
+import typer.{FrontEnd, ImportInfo, RefChecks, Typer}
+import reporting.{ConsoleReporter, Reporter}
 import Phases.Phase
 import transform._
 import util.FreshNameCreator
 import transform.TreeTransforms.{TreeTransform, TreeTransformer}
 import core.DenotTransformers.DenotTransformer
 import core.Denotations.SingleDenotation
-
-import dotty.tools.backend.jvm.{LabelDefs, GenBCode, CollectSuperCalls}
+import dotty.tools.backend.jvm.{CollectSuperCalls, GenBCode, LabelDefs}
+import dotty.tools.dotc.transform.linker.Simplify
 
 /** The central class of the dotc compiler. The job of a compiler is to create
  *  runs, which process given `phases` in a given `rootContext`.
@@ -60,6 +60,9 @@ class Compiler {
            new HoistSuperArgs,      // Hoist complex arguments of supercalls to enclosing scope
            new ClassOf),            // Expand `Predef.classOf` calls.
       List(new TryCatchPatterns,    // Compile cases in try/catch
+           new PatternConstantsFactorization, // extract common constant matches from patterns
+           new PatternTypeFactorization,      // extract common type matches from patterns
+
            new PatternMatcher,      // Compile pattern matches
            new ExplicitOuter,       // Add accessors to outer classes from nested ones.
            new ExplicitSelf,        // Make references to non-trivial self types explicit as casts
@@ -74,6 +77,7 @@ class Compiler {
            new ElimByName,          // Expand by-name parameter references
            new AugmentScala2Traits, // Expand traits defined in Scala 2.11 to simulate old-style rewritings
            new ResolveSuper,        // Implement super accessors and add forwarders to trait methods
+           new Simplify,            // Perform local optimizations, simplified versions of what linker does.
            new PrimitiveForwarders, // Add forwarders to trait methods that have a mismatch between generic and primitives
            new ArrayConstructors),  // Intercept creation of (non-generic) arrays and intrinsify.
       List(new Erasure),            // Rewrite types to JVM model, erasing all type parameters, abstract types and refinements.

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

@@ -434,6 +434,7 @@ object StdNames {
     val isArray: N              = "isArray"
     val isDefinedAt: N          = "isDefinedAt"
     val isDefinedAtImpl: N      = "$isDefinedAt"
+    val isDefined: N            = "isDefined"
     val isEmpty: N              = "isEmpty"
     val isInstanceOf_ : N       = "isInstanceOf"
     val java: N                 = "java"

src/dotty/tools/dotc/transform/linker/Analysis.scala renamed to compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala

@@ -56,7 +56,7 @@ object Analysis {
     "scala.runtime.BoxesRunTime.unboxToChar",
     "scala.runtime.BoxesRunTime.unboxToFloat"
   )
-
+  
   def effectsDontEscape(t: Tree)(implicit ctx: Context) = {
     t match {
       case Apply(fun, args) if fun.symbol.isConstructor && constructorWhiteList.contains(fun.symbol.owner.fullName.toString) =>

src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala renamed to compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala

@@ -110,4 +110,5 @@ class PatternConstantsFactorization extends PatternFactorization {
     val innerMatch = transformFollowing(Match(selector, cases))
     CaseDef(pattern, EmptyTree, innerMatch)
   }
+
 }

src/dotty/tools/dotc/transform/PatternFactorization.scala renamed to compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala

@@ -25,7 +25,7 @@ import TreeTransforms._
 trait PatternFactorization extends MiniPhaseTransform {
   import dotty.tools.dotc.ast.tpd._
 
-  protected def asInnerMatchIfNeeded(caseDefs: List[CaseDef], fallbackOpt: Option[Tree])(implicit ctx: Context, info: TransformerInfo): CaseDef
+  protected def asInnerMatchIfNeeded(selectorSym: Symbol, caseDefs: List[CaseDef], fallbackOpt: Option[Tree])(implicit ctx: Context, info: TransformerInfo): CaseDef
   protected def factorized(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): (List[List[CaseDef]], List[CaseDef])
   protected def shouldSwap(case1: CaseDef, case2: CaseDef)(implicit ctx: Context): Boolean
 
@@ -63,7 +63,7 @@ trait PatternFactorization extends MiniPhaseTransform {
         Apply(Ident(fallbackDefDef.symbol.termRef), Nil)
       }
 
-      val newFactoredCases = factoredCases.map(asInnerMatchIfNeeded(_, fallbackOpt))
+      val newFactoredCases = factoredCases.map(asInnerMatchIfNeeded(selectorSym, _, fallbackOpt))
 
       val fallbackCaseOpt = fallbackOpt.map { fallback =>
         CaseDef(Underscore(fallback.symbol.info), EmptyTree, fallback)