From 098036a25c57a9a0e631eb3afa76b5c4a7f3a66f Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 Aug 2016 10:15:56 +0200
Subject: [PATCH 01/88] Simplify: initial structure and first optimizations

---
 compiler/src/dotty/tools/dotc/ast/tpd.scala   |  26 +-
 .../dotc/transform/linker/Simplify.scala      | 527 ++++++++++++++++++
 tests/{pos => disabled}/t7126.scala           |   0
 3 files changed, 547 insertions(+), 6 deletions(-)
 create mode 100644 src/dotty/tools/dotc/transform/linker/Simplify.scala
 rename tests/{pos => disabled}/t7126.scala (100%)

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 690f18509ebd..c601530e9f85 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -472,15 +472,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply =
-      ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
+    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
+      val untyped = untpd.cpy.Apply(tree)(fun, args)
+      if (untyped ne tree)
+        ta.assignType(untyped, fun, args)
+      else tree.asInstanceOf[Apply]
+    }
       // Note: Reassigning the original type if `fun` and `args` have the same types as before
       // does not work here: The computed type depends on the widened function type, not
       // the function type itself. A treetransform may keep the function type the
       // same but its widened type might change.
 
-    override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply =
-      ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
+    override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
+      val untyped = untpd.cpy.TypeApply(tree)(fun, args)
+      if (untyped ne tree)
+        ta.assignType(untyped, fun, args)
+      else tree.asInstanceOf[TypeApply]
+    }
+    // FIXME
       // Same remark as for Apply
 
     override def Literal(tree: Tree)(const: Constant)(implicit ctx: Context): Literal =
@@ -514,8 +523,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure =
-      ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
+    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
+      val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
+      if (untyped ne tree)
+        ta.assignType(untyped, meth, tpt)
+      else tree.asInstanceOf[Closure]
+
+    }
       // Same remark as for Apply
 
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
new file mode 100644
index 000000000000..ea2ef24be1d0
--- /dev/null
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -0,0 +1,527 @@
+package dotty.tools.dotc.transform.linker
+
+import dotty.tools.dotc.{ast, core}
+import core._
+import Contexts._
+import dotty.tools.dotc.ast.Trees._
+import StdNames._
+import NameOps._
+import dotty.tools.dotc.ast.tpd
+import Symbols._
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.Types.{ExprType, MethodType, MethodicType, NoPrefix, TermRef, ThisType}
+import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import dotty.tools.dotc.transform.SymUtils._
+import Decorators._
+import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+
+import scala.collection.mutable
+import scala.collection.mutable.ListBuffer
+
+
+class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
+
+  import tpd._
+
+  override def phaseName: String = "simplify"
+
+  private def desugarIdent(i: Ident)(implicit ctx: Context): Option[tpd.Select] = {
+    i.tpe match {
+      case TermRef(prefix: TermRef, name) =>
+        Some(tpd.ref(prefix).select(i.symbol))
+      case TermRef(prefix: ThisType, name) =>
+        Some(tpd.This(prefix.cls).select(i.symbol))
+      case _ => None
+    }
+  }
+
+  private def dropCasts(t: Tree)(implicit ctx: Context): Tree = t match {
+    //case TypeApply(aio@Select(rec, nm), _) if aio.symbol == defn.Any_asInstanceOf => dropCasts(rec)
+    case Typed(t, tpe) => t
+    case _ => t
+  }
+
+  private def readingOnlyVals(t: Tree)(implicit ctx: Context): Boolean = dropCasts(t) match {
+    case Typed(exp, tpe) => readingOnlyVals(exp)
+    case Apply(Select(rec, _), Nil) =>
+      if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName)
+        readingOnlyVals(rec) // accessing a field of a product
+      else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
+        readingOnlyVals(rec)
+      else false
+    case Select(rec, _) if t.symbol.is(Flags.Method) =>
+      if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName)
+        readingOnlyVals(rec) // accessing a field of a product
+      else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
+        readingOnlyVals(rec)
+      else false
+    case Select(qual, _) if !t.symbol.is(Flags.Mutable) =>
+      readingOnlyVals(qual)
+    case t: Ident if !t.symbol.is(Flags.Mutable) && !t.symbol.is(Flags.Method) =>
+      desugarIdent(t) match {
+        case Some(t) => readingOnlyVals(t)
+        case None => true
+      }
+    case t: This => true
+    case _ => false
+  }
+
+  type Visitor = Tree => Unit
+  type ErasureCompatibility = Int
+  val BeforeErasure: ErasureCompatibility = 1
+  val AfterErasure: ErasureCompatibility  = 2
+  val BeforeAndAfterErasure: ErasureCompatibility  = BeforeErasure | AfterErasure
+
+  val NoVisitor: Visitor = (_) => ()
+  type Transformer = () => (Tree => Tree)
+  type Optimization = (Context) => (String, ErasureCompatibility, Visitor, Transformer)
+
+  private lazy val _optimizations = Seq(inlineCaseIntrinsics, inlineLabelsCalledOnce/*, devalify, dropNoEffects, inlineLocalObjects*//*, varify*/)
+  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+    if (!tree.symbol.is(Flags.Label)) {
+      var rhs0 = tree.rhs
+      var rhs1: Tree = null
+      val erasureCompatibility = if (ctx.erasedTypes) AfterErasure else BeforeErasure
+      while (rhs1 ne rhs0) {
+        rhs1 = rhs0
+        val initialized = _optimizations.map(x =>x(ctx.withOwner(tree.symbol)))
+        var (names, erasureSupport , visitors, transformers) = unzip4(initialized)
+        // todo: fuse for performance
+        while (names.nonEmpty) {
+          val nextVisitor = visitors.head
+          val supportsErasure = erasureSupport.head
+          if ((supportsErasure & erasureCompatibility) > 0) {
+            rhs0.foreachSubTree(nextVisitor)
+            val nextTransformer = transformers.head()
+            val name = names.head
+            val rhst = new TreeMap() {
+              override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = nextTransformer(super.transform(tree))
+            }.transform(rhs0)
+            if (rhst ne rhs0)
+              println(s"${tree.symbol} after ${name} became ${rhst.show}")
+            rhs0 = rhst
+          }
+          names = names.tail
+          visitors = visitors.tail
+          erasureSupport = erasureSupport.tail
+          transformers = transformers.tail
+        }
+      }
+      if (rhs0 ne tree.rhs) cpy.DefDef(tree)(rhs = rhs0)
+      else tree
+    } else tree
+  }
+
+  val inlineCaseIntrinsics: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val transformer: Transformer = () => {
+      case a: Apply if !a.tpe.isInstanceOf[MethodicType] && a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
+        (a.symbol.name == nme.apply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
+        def unrollArgs(t: Tree, l: List[List[Tree]]): List[List[Tree]] = t match {
+          case Apply(t, args) => unrollArgs(t, args :: l)
+          case _ => l
+        }
+        val argss = unrollArgs(a.fun, a.args :: Nil)
+        def rollInArgs(l: List[List[Tree]], fun: Tree): Tree = l match {
+          case head :: tail => rollInArgs(tail, fun.appliedToArgs(head))
+          case _ => fun
+        }
+        rollInArgs(argss.tail, tpd.New(a.tpe.dealias, argss.head))
+      case a: Apply if a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
+        (a.symbol.name == nme.unapply) && a.symbol.owner.companionClass.is(Flags.CaseClass) && !a.symbol.owner.is(Flags.Scala2x) =>
+        a.args.head
+      case t => t
+    }
+    ("inlineCaseIntrinsics", BeforeAndAfterErasure, NoVisitor, transformer)
+  }}
+
+  val inlineLocalObjects: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val hasPerfectRHS = collection.mutable.HashMap[Symbol, Boolean]() // in the end only calls constructor. Reason for unconditional inlining
+    val checkGood = collection.mutable.HashMap[Symbol, Symbol]() // if key has perfect RHS than value has perfect RHS
+    val gettersCalled = collection.mutable.HashSet[Symbol]()
+    def followTailPerfect(t: Tree, symbol: Symbol): Unit = {
+      t match {
+        case Block(_, expr) => followTailPerfect(expr, symbol)
+        case If(_, thenp, elsep) => followTailPerfect(thenp, symbol); followTailPerfect(elsep, symbol);
+        case Apply(fun, _) if fun.symbol.isConstructor && t.tpe.widenDealias == symbol.info.widenDealias.finalResultType.widenDealias =>
+          hasPerfectRHS(symbol) = true
+        case Apply(fun, _) if fun.symbol.is(Flags.Label) && (fun.symbol ne symbol) =>
+          checkGood.put(fun.symbol, symbol)
+        case t: Ident if !t.symbol.owner.isClass =>
+          checkGood.put(t.symbol, symbol)
+        case _ =>
+      }
+    }
+    val visitor: Visitor = {
+      case vdef: ValDef if vdef.symbol.info.classSymbol is Flags.CaseClass  =>
+        followTailPerfect(vdef.rhs, vdef.symbol)
+      case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
+        checkGood.put(rhs.symbol, lhs.symbol)
+      case t @ Select(qual, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
+        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
+        gettersCalled(qual.symbol) = true
+      case t: DefDef if t.symbol.is(Flags.Label) =>
+        followTailPerfect(t.rhs, t.symbol)
+      case _ =>
+    }
+
+    val transformer: Transformer = () =>{
+      var hasChanged = true
+      while(hasChanged) {
+        hasChanged = false
+        checkGood.foreach{case (key, value) =>
+          if (hasPerfectRHS.getOrElse(key, false)) {
+            hasChanged = !hasPerfectRHS.put(value, true).getOrElse(false)
+          }
+        }
+      }
+
+      val newMappings: Map[Symbol, Map[Symbol, Symbol]] =
+        hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Flags.Method) && !x.is(Flags.Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is Flags.CaseClass))
+          .map{ refVal =>
+            val fields = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
+          val productAccessors = (1 to fields.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // todo: disambiguate
+          val newLocals = fields.map(x =>
+            ctx.newSymbol(refVal.owner, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
+          )
+            val fieldMapping = fields zip newLocals
+            val productMappings = productAccessors zip newLocals
+            (refVal, (fieldMapping ++ productMappings).toMap)
+          }.toMap
+      val toSplit: mutable.Set[Symbol] = mutable.Set.empty ++ newMappings.keySet
+
+      def splitWrites(t: Tree, target: Symbol): Tree = {
+        t match {
+          case tree@ Block(stats, expr) => cpy.Block(tree)(stats, splitWrites(expr, target))
+          case tree@ If(_, thenp, elsep) => cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
+          case Apply(sel , args) if sel.symbol.isConstructor && t.tpe.widenDealias == target.info.widenDealias.finalResultType.widenDealias =>
+            val fieldsByAccessors = newMappings(target)
+            val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
+            val assigns = (accessors zip args) map (x => ref(fieldsByAccessors(x._1)).becomes(x._2))
+            val recreate = sel.appliedToArgs(accessors.map(x => ref(fieldsByAccessors(x))))
+            Block(assigns, recreate)
+          case Apply(fun, _) if fun.symbol.is(Flags.Label) =>
+            t // do nothing. it will do on its own
+          case t: Ident if !t.symbol.owner.isClass && newMappings.contains(t.symbol) && t.symbol.info.classSymbol == target.info.classSymbol =>
+            val fieldsByAccessorslhs = newMappings(target)
+            val fieldsByAccessorsrhs = newMappings(t.symbol)
+            val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
+            val assigns = accessors map (x => ref(fieldsByAccessorslhs(x)).becomes(ref(fieldsByAccessorsrhs(x))))
+            Block(assigns, t)
+          // if t is itself split, push writes
+          case _ =>
+            evalOnce(t){ev =>
+              val fieldsByAccessors = newMappings(target)
+              val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
+              val assigns = accessors map (x => ref(fieldsByAccessors(x)).becomes(ev.select(x)))
+              Block(assigns, ev)
+            } // need to eval-once and update fields
+
+        }
+      }
+
+      def followCases(t: Symbol): Symbol = if (t.symbol.is(Flags.Label)) {
+        followCases(checkGood.getOrElse(t, NoSymbol))
+      } else t
+
+      { (t: Tree) => t match {
+        case ddef: DefDef if ddef.symbol.is(Flags.Label) =>
+          newMappings.get(followCases(ddef.symbol)) match {
+            case Some(mappings) =>
+              cpy.DefDef(ddef)(rhs = splitWrites(ddef.rhs, followCases(ddef.symbol)))
+            case _ => ddef
+          }
+        case a: ValDef if toSplit.contains(a.symbol) =>
+          toSplit -= a.symbol
+          // break ValDef apart into fields + boxed value
+          val newFields = newMappings(a.symbol).values.toSet
+          Thicket(
+            newFields.map(x => tpd.ValDef(x.asTerm, EmptyTree)).toList :::
+              List(cpy.ValDef(a)(rhs = splitWrites(a.rhs, a.symbol))))
+        case ass: Assign =>
+          newMappings.get(ass.lhs.symbol) match {
+            case None =>   ass
+            case Some(mapping) =>
+              val updates = mapping.filter(x => x._1.is(Flags.CaseAccessor)).map(x => ref(x._2).becomes(ref(ass.lhs.symbol).select(x._1))).toList
+              Thicket(ass :: updates)
+          }
+        case sel @ Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
+          (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+          (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
+          newMappings.getOrElse(rec.symbol, Map.empty).get(sel.symbol) match {
+            case None => t
+            case Some(newSym) => ref(newSym)
+          }
+        case t => t
+      }}}
+    ("inlineLocalObjects", BeforeAndAfterErasure, visitor, transformer)
+  }}
+
+  private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
+    t match {
+      case t: Literal => EmptyTree
+      case Typed(exp, tpe) =>
+        keepOnlySideEffects(exp)
+      case t @ If(cond, EmptyTree, EmptyTree) =>
+        keepOnlySideEffects(cond)
+      case t @ If(cond, thenp, elsep) =>
+        cpy.If(t)(thenp = keepOnlySideEffects(thenp), elsep = keepOnlySideEffects(elsep))
+      case Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
+        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))=>
+        keepOnlySideEffects(rec) // accessing a field of a product
+      case Select(qual, _) if !t.symbol.is(Flags.Mutable) && (!t.symbol.is(Flags.Method) || t.symbol.isGetter) =>
+        keepOnlySideEffects(qual)
+      case Block(List(t: DefDef), s: Closure) => EmptyTree
+      case bl@Block(stats, expr) =>
+        val stats1 = stats.mapConserve(keepOnlySideEffects)
+        val stats2 = if (stats1 ne stats) stats1.filter(x=>x ne EmptyTree) else stats1
+        val expr2: tpd.Tree = expr match {
+          case t: Literal if t.tpe.derivesFrom(defn.UnitClass) => expr
+          case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
+        }
+        cpy.Block(bl)(stats2, expr2)
+      case t: Ident if !t.symbol.is(Flags.Method) =>
+        desugarIdent(t) match {
+          case Some(t) => t
+          case None => EmptyTree
+        }
+      case app: Apply if app.fun.symbol.is(Flags.Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
+        val denot = app.fun.symbol.denot
+        //println(s"replacing ${app.symbol}")
+        if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
+          val newLabelType = app.symbol.info match {
+            case mt: MethodType =>
+              mt.derivedMethodType(mt.paramNames, mt.paramTypes, defn.UnitType)
+            case et: ExprType =>
+              et.derivedExprType(defn.UnitType)
+          }
+          val newD = app.symbol.asSymDenotation.copySymDenotation(info = newLabelType)
+          newD.installAfter(this)
+        }
+
+        ref(app.symbol).appliedToArgs(app.args)
+      case t @ Apply(fun, _) if Analysis.effectsDontEscape(t) =>
+        def getArgsss(a: Tree): List[Tree] = a match {
+          case a: Apply => getArgsss(a.fun) ::: a.args
+          case _ => Nil
+        }
+        def getSel(t: Tree): Tree = {t match {
+          case t: Apply => getSel(t.fun)
+          case t: Select => t.qualifier
+          case t: TypeApply => getSel(t.fun)
+          case _ => t
+        }}
+        val args = getArgsss(t)
+        val rec = getSel(t)
+        val prefix = rec match {
+          case t: New =>
+            args.map(keepOnlySideEffects)
+          case _ =>
+            rec :: args.map(keepOnlySideEffects)
+        }
+        Block(prefix, tpd.unitLiteral)
+      case _ => t
+    }
+  }
+
+  val bubbleUpNothing: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val transformer: Transformer = () => {
+      case Apply(Select(qual, _), args)  if qual.tpe.derivesFrom(defn.NothingClass) => qual
+      case Apply(Select(qual, _), args)  if args.exists(x => x.tpe.derivesFrom(defn.NothingClass)) =>
+        val (keep, noth:: other) = args.span(x => !x.tpe.derivesFrom(defn.NothingClass))
+        Block(qual :: keep, noth)
+      case Assign(_, rhs) if rhs.tpe.derivesFrom(defn.NothingClass) =>
+        rhs
+      case If(cond, _, _) if cond.tpe.derivesFrom(defn.NothingClass) => cond
+      case a: Block if a.stats.exists(x => x.tpe.derivesFrom(defn.NothingClass))  =>
+        val (keep, noth:: other) = a.stats.span(x => !x.tpe.derivesFrom(defn.NothingClass))
+        Block(keep, noth)
+      case t => t
+    }
+    ("bubbleUpNothing", BeforeAndAfterErasure, NoVisitor, transformer)
+  }}
+
+  val dropNoEffects: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+
+    val transformer: Transformer = () => {
+      case Block(Nil, expr) => expr
+      case a: Block  =>
+        cpy.Block(a)(stats = a.stats.mapConserve(keepOnlySideEffects), a.expr)
+      case a: DefDef =>
+        if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass)) {
+          cpy.DefDef(a)(rhs = keepOnlySideEffects(a.rhs), tpt = tpd.TypeTree(defn.UnitType))
+        } else a
+      case t => t
+    }
+    ("dropNoEffects", BeforeAndAfterErasure, NoVisitor, transformer)
+  }}
+
+  val inlineLabelsCalledOnce: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val timesUsed = collection.mutable.HashMap[Symbol, Int]()
+    val defined = collection.mutable.HashMap[Symbol, DefDef]()
+
+    val visitor: Visitor = {
+      case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
+        var isRecursive = false
+        defdef.rhs.foreachSubTree(x => if (x.symbol == defdef.symbol) isRecursive = true)
+        if (!isRecursive) defined.put(defdef.symbol, defdef)
+      case t: Apply if t.symbol.is(Flags.Label) =>
+        val b4 = timesUsed.getOrElseUpdate(t.symbol, 0)
+        timesUsed.put(t.symbol, b4 + 1)
+      case _ =>
+    }
+
+    val transformer: Transformer = () => {
+      case a: Apply if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramTypess == List(Nil)=>
+        defined.get(a.symbol) match {
+          case None => a
+          case Some(defDef) =>
+            //println(s"Inlining ${defDef.name}")
+            defDef.rhs.changeOwner(defDef.symbol, ctx.owner)
+        }
+      case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
+        //println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
+        defined.put(a.symbol, a)
+        EmptyTree
+      case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 0 && defined.contains(a.symbol)) =>
+        //println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
+        EmptyTree
+      case t => t
+    }
+    ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
+  }}
+
+  val devalify: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val timesUsed = collection.mutable.HashMap[Symbol, Int]()
+    val defined = collection.mutable.HashSet[Symbol]()
+    val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
+    val visitor: Visitor = {
+      case valdef: ValDef if !valdef.symbol.is(Flags.Param) && !valdef.symbol.is(Flags.Mutable) && (valdef.symbol.exists && !valdef.symbol.owner.isClass) =>
+        defined += valdef.symbol
+
+        dropCasts(valdef.rhs) match {
+          case t: Tree if readingOnlyVals(t) =>
+            copies.put(valdef.symbol, valdef.rhs)
+          case _ =>
+        }
+      case valdef: ValDef  if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param) =>
+        //todo: handle params after constructors. Start changing public signatures by eliminating unused arguments.
+        defined += valdef.symbol
+
+      case t: RefTree =>
+        val b4 = timesUsed.getOrElseUpdate(t.symbol, 0)
+        timesUsed.put(t.symbol, b4 + 1)
+      case _ =>
+    }
+
+    val transformer: Transformer = () => {
+
+      val valsToDrop = defined -- timesUsed.keySet
+      val copiesToReplaceAsDuplicates = copies.filter { x =>
+        val rhs = dropCasts(x._2)
+        !rhs.symbol.owner.isClass && !rhs.symbol.is(Flags.Method) && !rhs.symbol.is(Flags.Mutable)
+      }
+      // todo: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
+
+      val copiesToReplaceAsUsedOnce =
+        timesUsed.filter(x => x._2 == 1).
+          flatMap(x => copies.get(x._1) match {
+            case Some(tr) => List((x._1, tr));
+            case None => Nil
+          })
+
+
+      val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce
+
+      val transformation: Tree => Tree = {
+        case t: ValDef if valsToDrop.contains(t.symbol) =>
+          // println(s"droping definition of ${t.symbol.showFullName} as not used")
+          t.rhs
+        case t: ValDef if replacements.contains(t.symbol) =>
+          // println(s"droping definition of ${t.symbol.showFullName} as an alias")
+          EmptyTree
+        case t: Block => // drop non-side-effecting stats
+          t
+        case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.is(Flags.Param) && !t.symbol.is(Flags.Mutable) =>
+          replacements.getOrElse(t.symbol, t)
+        case tree => tree
+      }
+
+      transformation
+    }
+    ("devalify", BeforeAndAfterErasure, visitor, transformer)
+  }}
+
+  val varify: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val paramsTimesUsed = collection.mutable.HashMap[Symbol, Int]()
+    val possibleRenames = collection.mutable.HashMap[Symbol, Set[Symbol]]()
+    val visitor: Visitor = {
+      case t: ValDef
+        if t.symbol.is(Flags.Param) =>
+        paramsTimesUsed += (t.symbol -> 0)
+      case valDef: ValDef
+        if valDef.symbol.is(Flags.Mutable) =>
+        valDef.rhs.foreachSubTree { subtree =>
+          if (paramsTimesUsed.contains(subtree.symbol) &&
+            valDef.symbol.info.widenDealias <:< subtree.symbol.info.widenDealias) {
+            val newSet = possibleRenames.getOrElse(valDef.symbol, Set.empty) + subtree.symbol
+            possibleRenames.put(valDef.symbol, newSet)
+          }
+        }
+      case t: RefTree
+        if paramsTimesUsed.contains(t.symbol) =>
+        val param = t.symbol
+        val current = paramsTimesUsed.get(param)
+        current foreach { c => paramsTimesUsed += (param -> (c + 1)) }
+      case _ =>
+    }
+    val transformer = () => {
+      val paramCandidates = paramsTimesUsed.filter(kv => kv._2 == 1).keySet
+      val renames = possibleRenames.iterator.map(kv => (kv._1, kv._2.intersect(paramCandidates))).
+        filter(x => x._2.nonEmpty).map(x => (x._1, x._2.head)).toMap
+      val transformation: Tree => Tree = {
+        case t: RefTree
+          if renames.contains(t.symbol) =>
+          ref(renames(t.symbol))
+        case t: ValDef
+          if renames.contains(t.symbol) =>
+          val replaced = renames(t.symbol)
+          if (t.rhs.symbol == replaced) EmptyTree
+          else ref(replaced).becomes(t.rhs)
+        case t: ValDef
+          if paramCandidates.contains(t.symbol) =>
+          t.symbol.flags = Flags.Mutable
+          t
+        case t => t
+      }
+      transformation
+    }
+    ("varify", AfterErasure, visitor, transformer)
+  }}
+
+
+  private def unzip4[A, B, C, D](seq: Seq[(A, B, C, D)]): (Seq[A], Seq[B], Seq[C], Seq[D]) = {
+    val listBuilderA = new ListBuffer[A]()
+    val listBuilderB = new ListBuffer[B]()
+    val listBuilderC = new ListBuffer[C]()
+    val listBuilderD = new ListBuffer[D]()
+    seq.foreach{x =>
+      listBuilderA += x._1
+      listBuilderB += x._2
+      listBuilderC += x._3
+      listBuilderD += x._4
+    }
+    (listBuilderA.toList, listBuilderB.toList, listBuilderC.toList, listBuilderD.toList)
+  }
+}
diff --git a/tests/pos/t7126.scala b/tests/disabled/t7126.scala
similarity index 100%
rename from tests/pos/t7126.scala
rename to tests/disabled/t7126.scala

From 968f4787a77370acd8abbc9f5c9bf9600621c144 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 Aug 2016 12:03:12 +0200
Subject: [PATCH 02/88] Simplify: add inlineOptions fixes to
 inlineCaseIntrinsics

---
 .../dotty/tools/dotc/core/Definitions.scala   |   4 +
 .../dotc/transform/linker/Simplify.scala      | 129 ++++++++++++++++--
 .../GenericTraversableTemplate.scala          |   0
 3 files changed, 118 insertions(+), 15 deletions(-)
 rename tests/{pos => disabled}/GenericTraversableTemplate.scala (100%)

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index e1d96af39e33..794141669362 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -521,6 +521,10 @@ class Definitions {
   def DynamicClass(implicit ctx: Context) = DynamicType.symbol.asClass
   lazy val OptionType: TypeRef                  = ctx.requiredClassRef("scala.Option")
   def OptionClass(implicit ctx: Context) = OptionType.symbol.asClass
+  lazy val SomeType: TypeRef                  = ctx.requiredClassRef("scala.Some")
+  def SomeClass(implicit ctx: Context) = SomeType.symbol.asClass
+  lazy val NoneModuleRef: TermRef                  = ctx.requiredModuleRef("scala.None")
+  def NoneClass(implicit ctx: Context) = NoneModuleRef.symbol.moduleClass.asClass
   lazy val EnumType: TypeRef                    = ctx.requiredClassRef("scala.Enum")
   def EnumClass(implicit ctx: Context) = EnumType.symbol.asClass
   lazy val EnumValuesType: TypeRef              = ctx.requiredClassRef("scala.runtime.EnumValues")
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index ea2ef24be1d0..042657c8078f 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -9,11 +9,12 @@ import NameOps._
 import dotty.tools.dotc.ast.tpd
 import Symbols._
 import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.core.Types.{ExprType, MethodType, MethodicType, NoPrefix, TermRef, ThisType}
+import dotty.tools.dotc.core.Types.{ExprType, MethodType, MethodicType, NoPrefix, NoType, TermRef, ThisType, Type}
 import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
-import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
 import dotty.tools.dotc.transform.SymUtils._
 import Decorators._
+import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
 
 import scala.collection.mutable
@@ -26,6 +27,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   override def phaseName: String = "simplify"
 
+  private var SeqFactoryClass: Symbol = null
+
+
+  override def prepareForUnit(tree: _root_.dotty.tools.dotc.ast.tpd.Tree)(implicit ctx: Context): TreeTransform = {
+    SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
+    this
+  }
+
   private def desugarIdent(i: Ident)(implicit ctx: Context): Option[tpd.Select] = {
     i.tpe match {
       case TermRef(prefix: TermRef, name) =>
@@ -79,7 +88,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   type Transformer = () => (Tree => Tree)
   type Optimization = (Context) => (String, ErasureCompatibility, Visitor, Transformer)
 
-  private lazy val _optimizations = Seq(inlineCaseIntrinsics, inlineLabelsCalledOnce/*, devalify, dropNoEffects, inlineLocalObjects*//*, varify*/)
+  private lazy val _optimizations = Seq(inlineCaseIntrinsics, inlineOptions, inlineLabelsCalledOnce, devalify, dropNoEffects, inlineLocalObjects/*, varify*/)
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     if (!tree.symbol.is(Flags.Label)) {
       var rhs0 = tree.rhs
@@ -101,7 +110,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = nextTransformer(super.transform(tree))
             }.transform(rhs0)
             if (rhst ne rhs0)
-              println(s"${tree.symbol} after ${name} became ${rhst.show}")
+              println(s"${tree.symbol} after ${name} became ${rhst.show(ctx.addMode(Mode.FutureDefsOK))}")
             rhs0 = rhst
           }
           names = names.tail
@@ -131,8 +140,28 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
         rollInArgs(argss.tail, tpd.New(a.tpe.dealias, argss.head))
       case a: Apply if a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
-        (a.symbol.name == nme.unapply) && a.symbol.owner.companionClass.is(Flags.CaseClass) && !a.symbol.owner.is(Flags.Scala2x) =>
-        a.args.head
+        (a.symbol.name == nme.unapply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
+        if (!a.symbol.owner.is(Flags.Scala2x))
+          a.args.head
+        else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass))
+          tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
+        else a
+      case a: Apply if (a.symbol.name == nme.unapplySeq) && a.symbol.owner.derivesFrom(SeqFactoryClass) && a.symbol.extendedOverriddenSymbols.isEmpty =>
+        def reciever(t: Tree): Type = t match {
+          case t: Apply => reciever(t.fun)
+          case t: TypeApply => reciever(t.fun)
+          case t: Ident => desugarIdent(t) match {
+            case Some(t) => reciever(t)
+            case _ => NoType
+          }
+          case t: Select =>
+            t.qualifier.tpe.widenDealias
+        }
+
+        val recv = reciever(a)
+        if (recv.typeSymbol.is(Flags.Module))
+          tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
+        else a
       case t => t
     }
     ("inlineCaseIntrinsics", BeforeAndAfterErasure, NoVisitor, transformer)
@@ -162,7 +191,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
         checkGood.put(rhs.symbol, lhs.symbol)
       case t @ Select(qual, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+        (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.maybeOwner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
         (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
         gettersCalled(qual.symbol) = true
       case t: DefDef if t.symbol.is(Flags.Label) =>
@@ -251,7 +280,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               Thicket(ass :: updates)
           }
         case sel @ Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-          (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+          (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
           (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
           newMappings.getOrElse(rec.symbol, Map.empty).get(sel.symbol) match {
             case None => t
@@ -356,7 +385,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case a: Block  =>
         cpy.Block(a)(stats = a.stats.mapConserve(keepOnlySideEffects), a.expr)
       case a: DefDef =>
-        if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass)) {
+        if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
           cpy.DefDef(a)(rhs = keepOnlySideEffects(a.rhs), tpt = tpd.TypeTree(defn.UnitType))
         } else a
       case t => t
@@ -400,13 +429,64 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
   }}
 
+  val inlineOptions: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val somes = collection.mutable.HashMap[Symbol, Tree]()
+    val nones = collection.mutable.HashSet[Symbol]()
+
+    val visitor: Visitor = {
+      case valdef: ValDef if !valdef.symbol.is(Flags.Mutable) &&
+        valdef.rhs.isInstanceOf[Apply] && valdef.rhs.tpe.derivesFrom(defn.SomeClass) &&
+        valdef.rhs.symbol.isPrimaryConstructor =>
+        val Apply(_, value) = valdef.rhs
+        somes(valdef.symbol) = value.head
+
+      case valdef: ValDef if !valdef.symbol.is(Flags.Mutable) &&
+        valdef.rhs.isInstanceOf[Apply] && valdef.rhs.tpe.derivesFrom(defn.NoneClass)  =>
+        nones += valdef.symbol
+      case _ =>
+    }
+
+    val transformer: Transformer = () => x => {
+      def rewriteSelect(x: Tree) = x match {
+        case Select(rec, nm) if nm == nme.get && somes.contains(rec.symbol) =>
+          somes(rec.symbol)
+        case Select(rec, nm) if nm == nme.isDefined &&
+          (rec.tpe.derivesFrom(defn.SomeClass) || somes.contains(rec.symbol)) =>
+          Literal(Constant(true))
+        case Select(rec, nm) if nm == nme.isEmpty &&
+          (rec.tpe.derivesFrom(defn.SomeClass) || somes.contains(rec.symbol)) =>
+          Literal(Constant(false))
+
+        case Select(rec, nm) if nm == nme.get && nones.contains(rec.symbol) =>
+          ref(defn.NoneModuleRef)
+        case Select(rec, nm) if nm == nme.isDefined &&
+          (rec.tpe.derivesFrom(defn.NoneClass) || nones.contains(rec.symbol)) =>
+          Literal(Constant(false))
+        case Select(rec, nm) if nm == nme.isEmpty &&
+          (rec.tpe.derivesFrom(defn.NoneClass) || nones.contains(rec.symbol)) =>
+          Literal(Constant(true))
+        case t => t
+      }
+      def dropApply(a: Tree): Tree = a match {
+        case Apply(fun, Nil) => fun
+        case _ => a
+      }
+      val old = dropApply(x)
+      val nw = rewriteSelect(old)
+      if (nw ne old) nw
+      else x
+    }
+    ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
+  }}
+
   val devalify: Optimization = { (ctx0: Context) => {
     implicit val ctx = ctx0
     val timesUsed = collection.mutable.HashMap[Symbol, Int]()
     val defined = collection.mutable.HashSet[Symbol]()
     val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
     val visitor: Visitor = {
-      case valdef: ValDef if !valdef.symbol.is(Flags.Param) && !valdef.symbol.is(Flags.Mutable) && (valdef.symbol.exists && !valdef.symbol.owner.isClass) =>
+      case valdef: ValDef if !valdef.symbol.is(Flags.Param) && !valdef.symbol.is(Flags.Mutable | Flags.Module) && (valdef.symbol.exists && !valdef.symbol.owner.isClass) =>
         defined += valdef.symbol
 
         dropCasts(valdef.rhs) match {
@@ -414,7 +494,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             copies.put(valdef.symbol, valdef.rhs)
           case _ =>
         }
-      case valdef: ValDef  if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param) =>
+      case t: New =>
+        val symIfExists = t.tpt.tpe.normalizedPrefix.termSymbol
+        val b4 = timesUsed.getOrElseUpdate(symIfExists, 0)
+        timesUsed.put(symIfExists, b4 + 1)
+
+      case valdef: ValDef  if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module) =>
         //todo: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 
@@ -443,17 +528,31 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce
 
+      val deepReplacer = new TreeMap() {
+        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+          def loop(tree: Tree):Tree  =
+            tree match {
+              case t: RefTree if replacements.contains(t.symbol) =>
+                loop(replacements(t.symbol))
+              case _ => tree
+            }
+          super.transform(loop(tree))
+        }
+      }
+
       val transformation: Tree => Tree = {
         case t: ValDef if valsToDrop.contains(t.symbol) =>
-          // println(s"droping definition of ${t.symbol.showFullName} as not used")
-          t.rhs
+          println(s"droping definition of ${t.symbol.showFullName} as not used")
+          t.rhs.changeOwner(t.symbol, t.symbol.owner)
         case t: ValDef if replacements.contains(t.symbol) =>
-          // println(s"droping definition of ${t.symbol.showFullName} as an alias")
+          println(s"droping definition of ${t.symbol.showFullName} as an alias")
           EmptyTree
         case t: Block => // drop non-side-effecting stats
           t
         case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.is(Flags.Param) && !t.symbol.is(Flags.Mutable) =>
-          replacements.getOrElse(t.symbol, t)
+          if (replacements.contains(t.symbol))
+            deepReplacer.transform(replacements(t.symbol))
+          else t
         case tree => tree
       }
 
diff --git a/tests/pos/GenericTraversableTemplate.scala b/tests/disabled/GenericTraversableTemplate.scala
similarity index 100%
rename from tests/pos/GenericTraversableTemplate.scala
rename to tests/disabled/GenericTraversableTemplate.scala

From e5924606126560888da472e5fd447b51059d05e1 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Jun 2016 19:12:04 +0200
Subject: [PATCH 03/88] Simplify: implement constant folding.

---
 .../dotc/transform/linker/Simplify.scala      | 34 +++++++++++++++++--
 1 file changed, 32 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 042657c8078f..f95fcab70284 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -9,13 +9,14 @@ import NameOps._
 import dotty.tools.dotc.ast.tpd
 import Symbols._
 import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.core.Types.{ExprType, MethodType, MethodicType, NoPrefix, NoType, TermRef, ThisType, Type}
+import dotty.tools.dotc.core.Types.{ConstantType,ExprType, MethodType, MethodicType, NoPrefix, NoType, TermRef, ThisType, Type}
 import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
 import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
 import dotty.tools.dotc.transform.SymUtils._
 import Decorators._
 import dotty.tools.dotc.core.Constants.Constant
 import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
+import dotty.tools.dotc.typer.ConstFold
 
 import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
@@ -75,6 +76,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case None => true
       }
     case t: This => true
+    case t: Literal => true
     case _ => false
   }
 
@@ -88,7 +90,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   type Transformer = () => (Tree => Tree)
   type Optimization = (Context) => (String, ErasureCompatibility, Visitor, Transformer)
 
-  private lazy val _optimizations = Seq(inlineCaseIntrinsics, inlineOptions, inlineLabelsCalledOnce, devalify, dropNoEffects, inlineLocalObjects/*, varify*/)
+  private lazy val _optimizations = Seq(inlineCaseIntrinsics, inlineOptions, inlineLabelsCalledOnce, devalify, dropNoEffects, inlineLocalObjects/*, varify*/, constantFold)
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     if (!tree.symbol.is(Flags.Label)) {
       var rhs0 = tree.rhs
@@ -166,6 +168,28 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
     ("inlineCaseIntrinsics", BeforeAndAfterErasure, NoVisitor, transformer)
   }}
+  
+  val constantFold: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val transformer: Transformer = () => {
+      case If(t: Literal, thenp, elsep) =>
+        if (t.const.booleanValue) thenp
+        else elsep
+      case t: Literal => t
+      case t: Match if (t.selector.tpe.isInstanceOf[ConstantType] && t.cases.forall(x => x.pat.tpe.isInstanceOf[ConstantType] || (tpd.isWildcardArg(x.pat) && x.guard.isEmpty))) =>
+        val selectorValue = t.selector.tpe.asInstanceOf[ConstantType].value
+        val better = t.cases.find(x => tpd.isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
+        if (better.nonEmpty) better.get.body
+        else t
+      case t =>
+        val s = ConstFold.apply(t)
+        if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {
+          val constant = s.tpe.asInstanceOf[ConstantType].value
+          Literal(constant)
+        } else t
+    }
+    ("constantFold", BeforeAndAfterErasure, NoVisitor, transformer)
+  }}
 
   val inlineLocalObjects: Optimization = { (ctx0: Context) => {
     implicit val ctx = ctx0
@@ -355,6 +379,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             rec :: args.map(keepOnlySideEffects)
         }
         Block(prefix, tpd.unitLiteral)
+      case t @ TypeApply(Select(rec, _), List(testType)) if t.symbol.eq(defn.Any_asInstanceOf) && testType.tpe.widenDealias.typeSymbol.exists =>
+        val receiverType = TypeErasure.erasure(rec.tpe)
+        val erazedTestedType = TypeErasure.erasure(testType.tpe)
+        if (receiverType.derivesFrom(erazedTestedType.typeSymbol))
+          EmptyTree
+        else t
       case _ => t
     }
   }

From fa7546369e40dead29f1e0b26d2ca806e250e020 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Jun 2016 19:12:52 +0200
Subject: [PATCH 04/88] Simplify: do not generate blocks with empty stats.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index f95fcab70284..ffcf31ef28dc 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -413,7 +413,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val transformer: Transformer = () => {
       case Block(Nil, expr) => expr
       case a: Block  =>
-        cpy.Block(a)(stats = a.stats.mapConserve(keepOnlySideEffects), a.expr)
+        val newStats = a.stats.mapConserve(keepOnlySideEffects)
+        if (newStats.nonEmpty)
+          cpy.Block(a)(stats = newStats, a.expr)
+        else a.expr
       case a: DefDef =>
         if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
           cpy.DefDef(a)(rhs = keepOnlySideEffects(a.rhs), tpt = tpd.TypeTree(defn.UnitType))

From fc9c60df2e8e39677a33998037705221ed9a363a Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Jun 2016 19:13:09 +0200
Subject: [PATCH 05/88] Simplify: devalify now also performs constant
 propagation

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index ffcf31ef28dc..0cb8dda0cd38 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -547,7 +547,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       val valsToDrop = defined -- timesUsed.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
         val rhs = dropCasts(x._2)
-        !rhs.symbol.owner.isClass && !rhs.symbol.is(Flags.Method) && !rhs.symbol.is(Flags.Mutable)
+        rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Flags.Method) && !rhs.symbol.is(Flags.Mutable))
       }
       // todo: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 

From ff0a8884ef6604b8edb4ecee4b878de6422cdab4 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 27 Jun 2016 19:20:04 +0200
Subject: [PATCH 06/88] Simplify: fix bug in bubbleUpNothing. Definitions
 should not be skipped.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 0cb8dda0cd38..96a5c2420d1f 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -394,14 +394,15 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val transformer: Transformer = () => {
       case Apply(Select(qual, _), args)  if qual.tpe.derivesFrom(defn.NothingClass) => qual
       case Apply(Select(qual, _), args)  if args.exists(x => x.tpe.derivesFrom(defn.NothingClass)) =>
-        val (keep, noth:: other) = args.span(x => !x.tpe.derivesFrom(defn.NothingClass))
+        val (keep, noth :: other) = args.span(x => !x.tpe.derivesFrom(defn.NothingClass))
         Block(qual :: keep, noth)
       case Assign(_, rhs) if rhs.tpe.derivesFrom(defn.NothingClass) =>
         rhs
       case If(cond, _, _) if cond.tpe.derivesFrom(defn.NothingClass) => cond
       case a: Block if a.stats.exists(x => x.tpe.derivesFrom(defn.NothingClass))  =>
-        val (keep, noth:: other) = a.stats.span(x => !x.tpe.derivesFrom(defn.NothingClass))
-        Block(keep, noth)
+        val (keep, noth :: other) = a.stats.span(x => !x.tpe.derivesFrom(defn.NothingClass))
+        val keep2 = other.filter(x => x.isDef)
+        Block(keep ::: keep2, noth)
       case t => t
     }
     ("bubbleUpNothing", BeforeAndAfterErasure, NoVisitor, transformer)

From 0e6de0a07f3bae5bfc411c99a64317f4e0fe6d69 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 28 Jun 2016 08:55:41 +0200
Subject: [PATCH 07/88] Simplify: improve constant folding & leave breadcrumbs
 for contributors

---
 .../dotty/tools/dotc/core/Definitions.scala   | 12 ++++
 .../dotc/transform/linker/Simplify.scala      | 55 ++++++++++++++++++-
 2 files changed, 64 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index 794141669362..a619c1a35dd3 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -430,6 +430,13 @@ class Definitions {
     lazy val Long_LSR_Int = LongType.member(nme.LSR).requiredSymbol(
       x => (x is Method) && (x.info.firstParamTypes.head isRef defn.IntClass)
     )
+    lazy val Long_plusR   = LongClass.requiredMethodRef(nme.PLUS, List(LongType))
+    def Long_+ = Long_plusR.symbol
+    lazy val Long_mulR   = LongClass.requiredMethodRef(nme.MUL, List(LongType))
+    def Long_* = Long_mulR.symbol
+    lazy val Long_divR   = LongClass.requiredMethodRef(nme.DIV, List(LongType))
+    def Long_/ = Long_divR.symbol
+
   lazy val FloatType: TypeRef = valueTypeRef("scala.Float", BoxedFloatType, java.lang.Float.TYPE, FloatEnc)
   def FloatClass(implicit ctx: Context) = FloatType.symbol.asClass
   lazy val DoubleType: TypeRef = valueTypeRef("scala.Double", BoxedDoubleType, java.lang.Double.TYPE, DoubleEnc)
@@ -490,6 +497,11 @@ class Definitions {
   lazy val BoxedNumberClass          = ctx.requiredClass("java.lang.Number")
   lazy val ThrowableClass            = ctx.requiredClass("java.lang.Throwable")
   lazy val ClassCastExceptionClass   = ctx.requiredClass("java.lang.ClassCastException")
+  lazy val ArithmeticExceptionClass  = ctx.requiredClass("java.lang.ArithmeticException")
+    lazy val ArithmeticExceptionClass_stringConstructor  = ArithmeticExceptionClass.info.member(nme.CONSTRUCTOR).suchThat(_.info.firstParamTypes match {
+      case List(pt) => (pt isRef StringClass)
+      case _ => false
+    }).symbol.asTerm
   lazy val JavaSerializableClass     = ctx.requiredClass("java.io.Serializable")
   lazy val ComparableClass           = ctx.requiredClass("java.lang.Comparable")
 
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 96a5c2420d1f..bac17939999d 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -29,10 +29,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   override def phaseName: String = "simplify"
 
   private var SeqFactoryClass: Symbol = null
+  private var symmetricOperations: Set[Symbol] = null
+
 
 
   override def prepareForUnit(tree: _root_.dotty.tools.dotc.ast.tpd.Tree)(implicit ctx: Context): TreeTransform = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
+    symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*, defn.String_+)
     this
   }
 
@@ -171,11 +174,57 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   
   val constantFold: Optimization = { (ctx0: Context) => {
     implicit val ctx = ctx0
-    val transformer: Transformer = () => {
+    def preEval(t: Tree) = {
+      if (t.isInstanceOf[Literal]) t else {
+        val s = ConstFold.apply(t)
+        if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {
+          val constant = s.tpe.asInstanceOf[ConstantType].value
+          Literal(constant)
+        } else t
+      }
+    }
+    val transformer: Transformer = () => { x => preEval(x) match {
+      // TODO: include handling of isInstanceOf similar to one in IsInstanceOfEvaluator
       case If(t: Literal, thenp, elsep) =>
         if (t.const.booleanValue) thenp
         else elsep
-      case t: Literal => t
+      case If(t@ Select(recv, _), thenp, elsep) if t.symbol eq defn.Boolean_! =>
+        tpd.If(recv, elsep, thenp)
+      case If(t@ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
+        tpd.If(recv, elsep, thenp)
+      // todo: similar trick for comparions.
+      // todo: handle comparison with min\max values
+      case t@Apply(Select(lhs, _), List(rhs)) =>
+        val sym = t.symbol
+        (lhs, rhs) match {
+          case (lhs, Literal(_)) if !lhs.isInstanceOf[Literal] && symmetricOperations.contains(sym) =>
+            rhs.select(sym).appliedTo(lhs)
+          case (l , _) if (sym == defn.Boolean_&&) && l.tpe.isInstanceOf[ConstantType]  =>
+            val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
+            if (const) Block(lhs :: Nil, rhs)
+            else l
+          case (l: Literal, _) if (sym == defn.Boolean_||) && l.tpe.isInstanceOf[ConstantType]   =>
+            val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
+            if (l.const.booleanValue) l
+            else Block(lhs :: Nil, rhs)
+          case (Literal(Constant(1)), _)    if sym == defn.Int_*  => rhs
+          case (Literal(Constant(0)), _)    if sym == defn.Int_+  => rhs
+          case (Literal(Constant(1L)), _)   if sym == defn.Long_* => rhs
+          case (Literal(Constant(0L)), _)   if sym == defn.Long_+ => rhs
+          // todo: same for float, double, short
+          // todo: empty string concat
+          // todo: disctribute & reorder constants
+          // todo: merge subsequent casts
+          case (_, Literal(Constant(1)))    if sym == defn.Int_/  => lhs
+          case (_, Literal(Constant(1L)))   if sym == defn.Long_/ => lhs
+          case (_, Literal(Constant(0)))    if sym == defn.Int_/  =>
+            Block(List(lhs),
+              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+          case (_, Literal(Constant(0L)))  if sym == defn.Long_/ =>
+            Block(List(lhs),
+              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+          case _ => t
+        }
       case t: Match if (t.selector.tpe.isInstanceOf[ConstantType] && t.cases.forall(x => x.pat.tpe.isInstanceOf[ConstantType] || (tpd.isWildcardArg(x.pat) && x.guard.isEmpty))) =>
         val selectorValue = t.selector.tpe.asInstanceOf[ConstantType].value
         val better = t.cases.find(x => tpd.isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
@@ -187,7 +236,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           val constant = s.tpe.asInstanceOf[ConstantType].value
           Literal(constant)
         } else t
-    }
+    }}
     ("constantFold", BeforeAndAfterErasure, NoVisitor, transformer)
   }}
 

From e024e8615b8ad734d7ab525b911ab39f9803b654 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 Aug 2016 15:02:34 +0200
Subject: [PATCH 08/88] Add PatternFactorization

---
 .../dotc/transform/PatternFactorization.scala | 99 +++++++++++++++++++
 .../dotc/transform/linker/Simplify.scala      |  2 +
 2 files changed, 101 insertions(+)
 create mode 100644 src/dotty/tools/dotc/transform/PatternFactorization.scala

diff --git a/src/dotty/tools/dotc/transform/PatternFactorization.scala b/src/dotty/tools/dotc/transform/PatternFactorization.scala
new file mode 100644
index 000000000000..6cff62ddce04
--- /dev/null
+++ b/src/dotty/tools/dotc/transform/PatternFactorization.scala
@@ -0,0 +1,99 @@
+package dotty.tools.dotc.transform
+
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.ast.Trees._
+import TreeTransforms._
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.ast.Trees._
+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 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
+
+  protected def hasCaseWithoutGuard(cases: List[CaseDef]): Boolean = {
+    cases.exists {
+      case CaseDef(_, EmptyTree, _) => true
+      case _                        => false
+    }
+  }
+
+  override def transformMatch(tree: Match)(implicit ctx: Context, info: TransformerInfo): Tree = {
+    //println(s">>> ${this.getClass.getName}.transformMatch  " + tree.selector.tpe.show + " " + tree.tpe.show)
+    //println(tree.show)
+    //tree.cases.foreach(println)
+    //println()
+    val (factoredCases, fallbackCases) = factorized(tree.cases)
+    if (factoredCases.nonEmpty) {
+      val selectorSym =
+        ctx.newSymbol(ctx.owner, ctx.freshName("selector").toTermName, Flags.Synthetic, tree.selector.tpe)
+      val selectorVal = ValDef(selectorSym, tree.selector)
+      val selector = Ident(selectorSym.termRef)
+
+      val fallbackDefDefOpt = {
+        if (fallbackCases.nonEmpty) {
+          val fallbackMatch = transformMatch(Match(selector, fallbackCases))
+          val fallbackName = ctx.freshName("fallback").toTermName
+          val fallbackSym =
+            ctx.newSymbol(ctx.owner, fallbackName, Flags.Synthetic | Flags.Label, MethodType(Nil, Nil)(x => fallbackMatch.tpe))
+          Some(DefDef(fallbackSym, fallbackMatch))
+        } else {
+          None
+        }
+      }
+      val fallbackOpt = fallbackDefDefOpt.map { fallbackDefDef =>
+        Apply(Ident(fallbackDefDef.symbol.termRef), Nil)
+      }
+
+      val newFactoredCases = factoredCases.map(asInnerMatchIfNeeded(_, fallbackOpt))
+
+      val fallbackCaseOpt = fallbackOpt.map { fallback =>
+        CaseDef(Underscore(fallback.symbol.info), EmptyTree, fallback)
+      }
+
+      Block(
+          List(selectorVal) ++ fallbackDefDefOpt,
+          transformFollowing(cpy.Match(tree)(selector, newFactoredCases ++ fallbackCaseOpt))
+      )
+    } else {
+      transformFollowing(tree)
+    }
+  }
+
+  protected def reorderedCases(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): List[CaseDef] = {
+    val casesArray = cases.toArray
+    var swapped = false
+    do {
+      swapped = false
+      for (i <- 1 until casesArray.length) {
+        val tmp1 = casesArray(i - 1)
+        val tmp2 = casesArray(i)
+        if (shouldSwap(tmp1, tmp2)) {
+          swapped = true
+          casesArray(i - 1) = tmp2
+          casesArray(i) = tmp1
+        }
+      }
+    } while (swapped)
+
+    casesArray.toList
+  }
+}
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index bac17939999d..948d07793580 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -230,6 +230,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val better = t.cases.find(x => tpd.isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
         if (better.nonEmpty) better.get.body
         else t
+      case t: Literal =>
+        t
       case t =>
         val s = ConstFold.apply(t)
         if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {

From b44e79672793fff6caba19ad68618e3e8ea89781 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:43:43 +0200
Subject: [PATCH 09/88] Simplify: fix owner corruption when inlining LabelDefs.

---
 .../dotc/transform/linker/Simplify.scala      | 60 ++++++++++++-------
 1 file changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 948d07793580..283b7065a504 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -90,12 +90,25 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   val BeforeAndAfterErasure: ErasureCompatibility  = BeforeErasure | AfterErasure
 
   val NoVisitor: Visitor = (_) => ()
-  type Transformer = () => (Tree => Tree)
+  type Transformer = () => (Context => Tree => Tree)
   type Optimization = (Context) => (String, ErasureCompatibility, Visitor, Transformer)
 
-  private lazy val _optimizations = Seq(inlineCaseIntrinsics, inlineOptions, inlineLabelsCalledOnce, devalify, dropNoEffects, inlineLocalObjects/*, varify*/, constantFold)
+  private lazy val _optimizations: Seq[Optimization] = Seq(
+    inlineCaseIntrinsics
+    ,inlineOptions
+    ,inlineLabelsCalledOnce
+    ,devalify
+//    ,dropNoEffects
+//    ,inlineLocalObjects // followCases needs to be fixed, see ./tests/pos/rbtree.scala
+    /*, varify*/  // varify could stop other transformations from being applied. postponed.
+    //, bubbleUpNothing
+    ,constantFold
+  )
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+    val ctx0 = ctx
     if (!tree.symbol.is(Flags.Label)) {
+      implicit val ctx: Context = ctx0.withOwner(tree.symbol(ctx0))
+      // TODO: optimize class bodies before erasure?
       var rhs0 = tree.rhs
       var rhs1: Tree = null
       val erasureCompatibility = if (ctx.erasedTypes) AfterErasure else BeforeErasure
@@ -112,10 +125,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val nextTransformer = transformers.head()
             val name = names.head
             val rhst = new TreeMap() {
-              override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = nextTransformer(super.transform(tree))
+              override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+                val innerCtx = if (tree.isDef && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
+                nextTransformer(ctx)(super.transform(tree)(innerCtx))
+              }
             }.transform(rhs0)
-            if (rhst ne rhs0)
-              println(s"${tree.symbol} after ${name} became ${rhst.show(ctx.addMode(Mode.FutureDefsOK))}")
+//            if (rhst ne rhs0)
+//              println(s"${tree.symbol} after ${name} became ${rhst.show}")
             rhs0 = rhst
           }
           names = names.tail
@@ -130,8 +146,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }
 
   val inlineCaseIntrinsics: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
-    val transformer: Transformer = () => {
+    implicit val ctx: Context = ctx0
+    val transformer: Transformer = () => localCtx => {
       case a: Apply if !a.tpe.isInstanceOf[MethodicType] && a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
         (a.symbol.name == nme.apply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
         def unrollArgs(t: Tree, l: List[List[Tree]]): List[List[Tree]] = t match {
@@ -173,7 +189,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
   
   val constantFold: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     def preEval(t: Tree) = {
       if (t.isInstanceOf[Literal]) t else {
         val s = ConstFold.apply(t)
@@ -243,7 +259,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
 
   val inlineLocalObjects: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     val hasPerfectRHS = collection.mutable.HashMap[Symbol, Boolean]() // in the end only calls constructor. Reason for unconditional inlining
     val checkGood = collection.mutable.HashMap[Symbol, Symbol]() // if key has perfect RHS than value has perfect RHS
     val gettersCalled = collection.mutable.HashSet[Symbol]()
@@ -274,7 +290,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case _ =>
     }
 
-    val transformer: Transformer = () =>{
+    val transformer: Transformer = () => localCtx => {
       var hasChanged = true
       while(hasChanged) {
         hasChanged = false
@@ -460,9 +476,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
 
   val dropNoEffects: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
 
-    val transformer: Transformer = () => {
+    val transformer: Transformer = () => localCtx => {
       case Block(Nil, expr) => expr
       case a: Block  =>
         val newStats = a.stats.mapConserve(keepOnlySideEffects)
@@ -479,7 +495,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
 
   val inlineLabelsCalledOnce: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     val timesUsed = collection.mutable.HashMap[Symbol, Int]()
     val defined = collection.mutable.HashMap[Symbol, DefDef]()
 
@@ -494,13 +510,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case _ =>
     }
 
-    val transformer: Transformer = () => {
+    val transformer: Transformer = () => localCtx => {
       case a: Apply if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramTypess == List(Nil)=>
         defined.get(a.symbol) match {
           case None => a
           case Some(defDef) =>
-            //println(s"Inlining ${defDef.name}")
-            defDef.rhs.changeOwner(defDef.symbol, ctx.owner)
+            println(s"Inlining ${defDef.name}")
+            defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
         }
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
         //println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
@@ -515,7 +531,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
 
   val inlineOptions: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     val somes = collection.mutable.HashMap[Symbol, Tree]()
     val nones = collection.mutable.HashSet[Symbol]()
 
@@ -532,7 +548,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case _ =>
     }
 
-    val transformer: Transformer = () => x => {
+    val transformer: Transformer = () => localCtx => tree => {
       def rewriteSelect(x: Tree) = x match {
         case Select(rec, nm) if nm == nme.get && somes.contains(rec.symbol) =>
           somes(rec.symbol)
@@ -566,7 +582,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
 
   val devalify: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     val timesUsed = collection.mutable.HashMap[Symbol, Int]()
     val defined = collection.mutable.HashSet[Symbol]()
     val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
@@ -594,7 +610,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case _ =>
     }
 
-    val transformer: Transformer = () => {
+    val transformer: Transformer = () => localCtx => {
 
       val valsToDrop = defined -- timesUsed.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
@@ -647,7 +663,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }}
 
   val varify: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     val paramsTimesUsed = collection.mutable.HashMap[Symbol, Int]()
     val possibleRenames = collection.mutable.HashMap[Symbol, Set[Symbol]]()
     val visitor: Visitor = {
@@ -670,7 +686,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         current foreach { c => paramsTimesUsed += (param -> (c + 1)) }
       case _ =>
     }
-    val transformer = () => {
+    val transformer: Transformer = () => localCtx => {
       val paramCandidates = paramsTimesUsed.filter(kv => kv._2 == 1).keySet
       val renames = possibleRenames.iterator.map(kv => (kv._1, kv._2.intersect(paramCandidates))).
         filter(x => x._2.nonEmpty).map(x => (x._1, x._2.head)).toMap

From a1c1f7f58c23132e30a99ec33da5681a47536e13 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:44:30 +0200
Subject: [PATCH 10/88] Simplify: Start getting rid from Scala2 options and
 tupples in patterns

---
 .../tools/dotc/transform/linker/Simplify.scala     | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 283b7065a504..0afabf2664e5 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -164,8 +164,18 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         (a.symbol.name == nme.unapply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
         if (!a.symbol.owner.is(Flags.Scala2x))
           a.args.head
-        else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass))
-          tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
+        else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
+          val accessors = a.args.head.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Flags.Method))
+          val fields = accessors.map(x => a.args.head.select(x).ensureApplied)
+          val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
+
+          if (!fields.tail.isEmpty) {
+            val tplAlloc = tpd.New(tplType, fields)
+            tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
+          } else { // scalac does not have tupple1
+            tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), fields.head :: Nil)
+          }
+        }
         else a
       case a: Apply if (a.symbol.name == nme.unapplySeq) && a.symbol.owner.derivesFrom(SeqFactoryClass) && a.symbol.extendedOverriddenSymbols.isEmpty =>
         def reciever(t: Tree): Type = t match {

From 5974a8023e363d2131a47d393b8caf6172679994 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:44:57 +0200
Subject: [PATCH 11/88] Simplify: Don't alias lazy vals

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 0afabf2664e5..d5d4820e8cce 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -583,10 +583,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case Apply(fun, Nil) => fun
         case _ => a
       }
-      val old = dropApply(x)
+      val old = dropApply(tree)
       val nw = rewriteSelect(old)
       if (nw ne old) nw
-      else x
+      else tree
     }
     ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
   }}
@@ -597,11 +597,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val defined = collection.mutable.HashSet[Symbol]()
     val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
     val visitor: Visitor = {
-      case valdef: ValDef if !valdef.symbol.is(Flags.Param) && !valdef.symbol.is(Flags.Mutable | Flags.Module) && (valdef.symbol.exists && !valdef.symbol.owner.isClass) =>
+      case valdef: ValDef if !valdef.symbol.is(Flags.Param) && !valdef.symbol.is(Flags.Mutable | Flags.Module | Flags.Lazy) && (valdef.symbol.exists && !valdef.symbol.owner.isClass) =>
         defined += valdef.symbol
 
         dropCasts(valdef.rhs) match {
           case t: Tree if readingOnlyVals(t) =>
+            if (valdef.symbol.name.toString.contains("21"))
+              println("dss")
             copies.put(valdef.symbol, valdef.rhs)
           case _ =>
         }
@@ -610,7 +612,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val b4 = timesUsed.getOrElseUpdate(symIfExists, 0)
         timesUsed.put(symIfExists, b4 + 1)
 
-      case valdef: ValDef  if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module) =>
+      case valdef: ValDef  if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
         //todo: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 

From 626488ac0b96da49f988f18db4ba358e07f503f1 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:45:27 +0200
Subject: [PATCH 12/88] Simplify: Don't create empty DefDefs if they should do
 nothing.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index d5d4820e8cce..a4ed9db012d0 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -497,7 +497,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         else a.expr
       case a: DefDef =>
         if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
-          cpy.DefDef(a)(rhs = keepOnlySideEffects(a.rhs), tpt = tpd.TypeTree(defn.UnitType))
+          def insertUnit(t: Tree) = {
+            if (!t.tpe.derivesFrom(defn.UnitClass)) Block(t :: Nil, tpd.unitLiteral)
+            else t
+          }
+          cpy.DefDef(a)(rhs = insertUnit(keepOnlySideEffects(a.rhs)), tpt = tpd.TypeTree(defn.UnitType))
         } else a
       case t => t
     }

From f66ac7ff959d1f1289d4ac38db6988f86b2496b2 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:45:51 +0200
Subject: [PATCH 13/88] Simplify: Fix bug with elimination of side-effects.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index a4ed9db012d0..65362d0dcf86 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -201,7 +201,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   val constantFold: Optimization = { (ctx0: Context) => {
     implicit val ctx: Context = ctx0
     def preEval(t: Tree) = {
-      if (t.isInstanceOf[Literal]) t else {
+      if (t.isInstanceOf[Literal] || t.isInstanceOf[CaseDef] || !isPureExpr(t)) t else {
         val s = ConstFold.apply(t)
         if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {
           val constant = s.tpe.asInstanceOf[ConstantType].value

From 9cdc55708873d56f21e5ca9a2fc8408302ebb059 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:47:01 +0200
Subject: [PATCH 14/88] Simplify: Don't partials-evaluate case-defs.

---
 .../tools/dotc/transform/linker/Simplify.scala   | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 65362d0dcf86..e0b5ba883547 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -23,6 +23,13 @@ import scala.collection.mutable.ListBuffer
 
 
 class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
+  // todo: optimize patterns similar to
+  //       if fact27.ne(null) then
+  //         if fact27.exists.unary_! then
+  //           this.myUninstVars.+=(fact27)
+  //         else case701()
+  //       else case701()
+  // two ifs can be joined together
 
   import tpd._
 
@@ -209,8 +216,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         } else t
       }
     }
-    val transformer: Transformer = () => { x => preEval(x) match {
+    val transformer: Transformer = () => localCtx => { x => preEval(x) match {
       // TODO: include handling of isInstanceOf similar to one in IsInstanceOfEvaluator
+      // TODO: include methods such as Int.int2double(see ./tests/pos/harmonize.scala)
       case If(t: Literal, thenp, elsep) =>
         if (t.const.booleanValue) thenp
         else elsep
@@ -218,7 +226,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         tpd.If(recv, elsep, thenp)
       case If(t@ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         tpd.If(recv, elsep, thenp)
-      // todo: similar trick for comparions.
+      // todo: similar trick for comparisons.
       // todo: handle comparison with min\max values
       case t@Apply(Select(lhs, _), List(rhs)) =>
         val sym = t.symbol
@@ -258,6 +266,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         else t
       case t: Literal =>
         t
+      case t: CaseDef =>
+        t
+      case t if !isPureExpr(t) =>
+        t
       case t =>
         val s = ConstFold.apply(t)
         if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {

From f521d86ddf181806f616b23cdb7a5a63f946213a Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:48:05 +0200
Subject: [PATCH 15/88] Simplify: make object inlining robust against Nothing.

---
 .../tools/dotc/transform/linker/Simplify.scala   | 16 +++++++++++-----
 1 file changed, 11 insertions(+), 5 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index e0b5ba883547..c3df4d8cefee 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -293,7 +293,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           hasPerfectRHS(symbol) = true
         case Apply(fun, _) if fun.symbol.is(Flags.Label) && (fun.symbol ne symbol) =>
           checkGood.put(fun.symbol, symbol)
-        case t: Ident if !t.symbol.owner.isClass =>
+        case t: Ident if !t.symbol.owner.isClass && (t.symbol ne symbol) =>
           checkGood.put(t.symbol, symbol)
         case _ =>
       }
@@ -329,6 +329,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val fields = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
           val productAccessors = (1 to fields.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // todo: disambiguate
           val newLocals = fields.map(x =>
+            // todo: it would be nice to have an additional optimization that
+            // todo: is capable of turning those mutable ones into immutable in common cases
             ctx.newSymbol(refVal.owner, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
           )
             val fieldMapping = fields zip newLocals
@@ -358,16 +360,20 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           // if t is itself split, push writes
           case _ =>
             evalOnce(t){ev =>
-              val fieldsByAccessors = newMappings(target)
-              val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
-              val assigns = accessors map (x => ref(fieldsByAccessors(x)).becomes(ev.select(x)))
-              Block(assigns, ev)
+              if (ev.tpe.derivesFrom(defn.NothingClass)) ev
+              else {
+                val fieldsByAccessors = newMappings(target)
+                val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
+                val assigns = accessors map (x => ref(fieldsByAccessors(x)).becomes(ev.select(x)))
+                Block(assigns, ev)
+              }
             } // need to eval-once and update fields
 
         }
       }
 
       def followCases(t: Symbol): Symbol = if (t.symbol.is(Flags.Label)) {
+        // todo: this can create cycles, see ./tests/pos/rbtree.scala
         followCases(checkGood.getOrElse(t, NoSymbol))
       } else t
 

From e111da94e1f313a07fcbca984522d2bd563afb64 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 30 Aug 2016 22:48:44 +0200
Subject: [PATCH 16/88] Simplify: Fix several infinite cycles.

---
 .../tools/dotc/transform/linker/Simplify.scala      | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index c3df4d8cefee..ffcc0dc42eac 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -418,7 +418,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t @ If(cond, EmptyTree, EmptyTree) =>
         keepOnlySideEffects(cond)
       case t @ If(cond, thenp, elsep) =>
-        cpy.If(t)(thenp = keepOnlySideEffects(thenp), elsep = keepOnlySideEffects(elsep))
+        val nthenp = keepOnlySideEffects(thenp)
+        val nelsep = keepOnlySideEffects(elsep)
+        if (thenp.isEmpty && elsep.isEmpty) keepOnlySideEffects(cond)
+        else cpy.If(t)(
+          thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else  tpd.unitLiteral),
+          elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else  tpd.unitLiteral))
       case Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
         (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
         (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))=>
@@ -485,8 +490,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }
 
   val bubbleUpNothing: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
-    val transformer: Transformer = () => {
+    implicit val ctx: Context = ctx0
+    val transformer: Transformer = () => localCtx => {
       case Apply(Select(qual, _), args)  if qual.tpe.derivesFrom(defn.NothingClass) => qual
       case Apply(Select(qual, _), args)  if args.exists(x => x.tpe.derivesFrom(defn.NothingClass)) =>
         val (keep, noth :: other) = args.span(x => !x.tpe.derivesFrom(defn.NothingClass))
@@ -686,7 +691,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           t
         case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.is(Flags.Param) && !t.symbol.is(Flags.Mutable) =>
           if (replacements.contains(t.symbol))
-            deepReplacer.transform(replacements(t.symbol))
+            deepReplacer.transform(replacements(t.symbol)).ensureConforms(t.tpe.widen)
           else t
         case tree => tree
       }

From c3f518ae131b0be75770934e85dd5d609aa63a43 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 16:17:55 +0200
Subject: [PATCH 17/88] Simplify: Don't drop lazy val reads.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index ffcc0dc42eac..9f0053441377 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -415,8 +415,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t: Literal => EmptyTree
       case Typed(exp, tpe) =>
         keepOnlySideEffects(exp)
-      case t @ If(cond, EmptyTree, EmptyTree) =>
-        keepOnlySideEffects(cond)
       case t @ If(cond, thenp, elsep) =>
         val nthenp = keepOnlySideEffects(thenp)
         val nelsep = keepOnlySideEffects(elsep)
@@ -428,7 +426,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
         (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))=>
         keepOnlySideEffects(rec) // accessing a field of a product
-      case Select(qual, _) if !t.symbol.is(Flags.Mutable) && (!t.symbol.is(Flags.Method) || t.symbol.isGetter) =>
+      case Select(qual, _) if !t.symbol.is(Flags.Mutable | Flags.Lazy) && (!t.symbol.is(Flags.Method) || t.symbol.isGetter) =>
         keepOnlySideEffects(qual)
       case Block(List(t: DefDef), s: Closure) => EmptyTree
       case bl@Block(stats, expr) =>
@@ -439,7 +437,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
         cpy.Block(bl)(stats2, expr2)
-      case t: Ident if !t.symbol.is(Flags.Method) =>
+      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) =>
         desugarIdent(t) match {
           case Some(t) => t
           case None => EmptyTree

From 315728da65c53bf55e2edbbc541b56b84856dc67 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 16:18:54 +0200
Subject: [PATCH 18/88] Simplify: jump jump: optimise label-defs that are
 themselves forwarders

---
 .../dotc/transform/linker/Simplify.scala      | 35 ++++++++++++++++++-
 1 file changed, 34 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 9f0053441377..69aa8d337e23 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -105,7 +105,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ,inlineOptions
     ,inlineLabelsCalledOnce
     ,devalify
-//    ,dropNoEffects
+    ,jumpjump
+    ,dropNoEffects
 //    ,inlineLocalObjects // followCases needs to be fixed, see ./tests/pos/rbtree.scala
     /*, varify*/  // varify could stop other transformations from being applied. postponed.
     //, bubbleUpNothing
@@ -565,6 +566,38 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
   }}
 
+  val jumpjump: Optimization = { (ctx0: Context) => {
+    // optimize label defs that call other label-defs
+    implicit val ctx: Context = ctx0
+    val defined = collection.mutable.HashMap[Symbol, Symbol]()
+
+    val visitor: Visitor = {
+      case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
+        defdef.rhs match {
+          case Apply(t, args) if t.symbol.is(Flags.Label) &&
+            TypeErasure.erasure(defdef.symbol.info.finalResultType).classSymbol == TypeErasure.erasure(t.symbol.info.finalResultType).classSymbol
+            && (args zip defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol) =>
+              defined(defdef.symbol) = t.symbol
+          case _ =>
+        }
+      case _ =>
+    }
+
+    val transformer: Transformer = () => localCtx => {
+      case a: Apply if  defined.contains(a.fun.symbol)=>
+        defined.get(a.symbol) match {
+          case None => a
+          case Some(fwd) =>
+            ref(fwd).appliedToArgs(a.args)
+        }
+      case a: DefDef if defined.contains(a.symbol) =>
+        println(s"dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
+        EmptyTree
+      case t => t
+    }
+    ("jumpjump", BeforeAndAfterErasure, visitor, transformer)
+  }}
+
   val inlineOptions: Optimization = { (ctx0: Context) => {
     implicit val ctx: Context = ctx0
     val somes = collection.mutable.HashMap[Symbol, Tree]()

From a9930f4ea9be5328b7051b9ca2ecc4b7d4fb6bc9 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 16:19:14 +0200
Subject: [PATCH 19/88] Simplify: start joining ifs if branches are similar.

---
 .../dotc/transform/linker/Simplify.scala      | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 69aa8d337e23..2f67c7e1c73b 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -217,9 +217,53 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         } else t
       }
     }
+
+    def isSimilar(t1: Tree, t2: Tree): Boolean = t1 match {
+      case t1: Apply =>
+        t2 match {
+          case t2: Apply =>
+            (t1.symbol == t2.symbol) && (t1.args zip t2.args).forall(x => isSimilar(x._1, x._2))
+          case _ => false
+        }
+      case t1: Ident =>
+        desugarIdent(t1) match {
+          case Some(t) =>
+            val t2i = t2 match {
+              case t2: Ident => desugarIdent(t2).getOrElse(t2)
+              case _ => t2
+            }
+            isSimilar(t, t2i)
+          case None => t1.symbol eq t2.symbol
+        }
+      case t1: Select => t2 match {
+        case t2: Select => (t1.symbol eq t2.symbol) && isSimilar(t1.qualifier, t2.qualifier)
+        case t2: Ident => desugarIdent(t2) match {
+          case Some(t2) => isSimilar(t1, t2)
+          case None => false
+        }
+        case _ => false
+      }
+      case t1: Literal => t2 match {
+        case t2: Literal if t1.const.tag == t2.const.tag && t1.const.value == t2.const.value =>
+          true
+        case _ => false
+      }
+      case _ => false
+    }
+
     val transformer: Transformer = () => localCtx => { x => preEval(x) match {
       // TODO: include handling of isInstanceOf similar to one in IsInstanceOfEvaluator
       // TODO: include methods such as Int.int2double(see ./tests/pos/harmonize.scala)
+      case If(cond1, thenp, elsep) if isSimilar(thenp, elsep) =>
+        Block(cond1 :: Nil, thenp)
+      case If(cond1, If(cond2, thenp2, elsep2), elsep1) if isSimilar(elsep1, elsep2) =>
+        If(cond1.select(defn.Boolean_&&).appliedTo(cond2), thenp2, elsep1)
+      case If(cond1, If(cond2, thenp2, elsep2), elsep1) if isSimilar(elsep1, thenp2) =>
+        If(cond1.select(defn.Boolean_!).select(defn.Boolean_||).appliedTo(cond2), elsep1, elsep2)
+      case If(cond1, thenp1, If(cond2, thenp2, elsep2)) if isSimilar(thenp1, thenp2) =>
+        If(cond1.select(defn.Boolean_||).appliedTo(cond2), thenp1, elsep2)
+      case If(cond1, thenp1, If(cond2, thenp2, elsep2)) if isSimilar(thenp1, elsep2) =>
+        If(cond1.select(defn.Boolean_||).appliedTo(cond2.select(defn.Boolean_!)), thenp1, thenp2)
       case If(t: Literal, thenp, elsep) =>
         if (t.const.booleanValue) thenp
         else elsep

From e4d36eafe02c23432012c425bacbd2e63f70ff31 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 17:42:06 +0200
Subject: [PATCH 20/88] Simplify: String+ isn't symmetric

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 2f67c7e1c73b..65fa70ce9600 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -42,7 +42,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   override def prepareForUnit(tree: _root_.dotty.tools.dotc.ast.tpd.Tree)(implicit ctx: Context): TreeTransform = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
-    symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*, defn.String_+)
+    symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
     this
   }
 

From cc1b78f9a12e21c29898bd8b5246b8b6e8e4f8ea Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 17:43:00 +0200
Subject: [PATCH 21/88] Simplify: fix a bug inside isSimilar

Applies need to have same receiver :-)
---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 12 +++++-------
 1 file changed, 5 insertions(+), 7 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 65fa70ce9600..5a5268165595 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -222,7 +222,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t1: Apply =>
         t2 match {
           case t2: Apply =>
-            (t1.symbol == t2.symbol) && (t1.args zip t2.args).forall(x => isSimilar(x._1, x._2))
+            (t1.symbol == t2.symbol) && (t1.args zip t2.args).forall(x => isSimilar(x._1, x._2)) && isSimilar(t1.fun, t2.fun)
           case _ => false
         }
       case t1: Ident =>
@@ -595,7 +595,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         defined.get(a.symbol) match {
           case None => a
           case Some(defDef) =>
-            println(s"Inlining ${defDef.name}")
+            //println(s"Inlining ${defDef.name}")
             defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
         }
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
@@ -635,7 +635,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             ref(fwd).appliedToArgs(a.args)
         }
       case a: DefDef if defined.contains(a.symbol) =>
-        println(s"dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
+        //println(s"dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
         EmptyTree
       case t => t
     }
@@ -704,8 +704,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
         dropCasts(valdef.rhs) match {
           case t: Tree if readingOnlyVals(t) =>
-            if (valdef.symbol.name.toString.contains("21"))
-              println("dss")
             copies.put(valdef.symbol, valdef.rhs)
           case _ =>
         }
@@ -757,10 +755,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       val transformation: Tree => Tree = {
         case t: ValDef if valsToDrop.contains(t.symbol) =>
-          println(s"droping definition of ${t.symbol.showFullName} as not used")
+          //println(s"droping definition of ${t.symbol.showFullName} as not used")
           t.rhs.changeOwner(t.symbol, t.symbol.owner)
         case t: ValDef if replacements.contains(t.symbol) =>
-          println(s"droping definition of ${t.symbol.showFullName} as an alias")
+          //println(s"droping definition of ${t.symbol.showFullName} as an alias")
           EmptyTree
         case t: Block => // drop non-side-effecting stats
           t

From 05c2afd2521a0a55c07d97b3af351aae54aaa4a0 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 17:43:26 +0200
Subject: [PATCH 22/88] Simplify: don't remove by-name calls

They may have side-effects, unlike reading other arguments.
---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 5a5268165595..bd7c443ace72 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -482,7 +482,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
         cpy.Block(bl)(stats2, expr2)
-      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) =>
+      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) && t.tpe.isInstanceOf[ExprType] =>
         desugarIdent(t) match {
           case Some(t) => t
           case None => EmptyTree

From 9d288e18345905543f1097c4427f6ee0a4d177e9 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 17:44:05 +0200
Subject: [PATCH 23/88] Simplify: don't remove infinite cycles :-)

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index bd7c443ace72..6d61c292571f 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -620,7 +620,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         defdef.rhs match {
           case Apply(t, args) if t.symbol.is(Flags.Label) &&
             TypeErasure.erasure(defdef.symbol.info.finalResultType).classSymbol == TypeErasure.erasure(t.symbol.info.finalResultType).classSymbol
-            && (args zip defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol) =>
+            && (args zip defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol)  && !(defdef.symbol eq t.symbol) =>
               defined(defdef.symbol) = t.symbol
           case _ =>
         }

From 5e70a0b8c0f39ce9864f423c6af9a20b5641f8ab Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 31 Aug 2016 21:17:53 +0200
Subject: [PATCH 24/88] Got tired of fixing Pattern*Factorization.

Will get back to it later.
---
 .../PatternConstantsFactorization.scala       | 113 ++++++++++++++++++
 .../transform/PatternTypeFactorization.scala  |  81 +++++++++++++
 .../dotc/transform/linker/Simplify.scala      |  60 +++++-----
 tests/disabled/patternFactorization.scala     | 107 +++++++++++++++++
 tests/{run => disabled}/statics.scala         |   0
 5 files changed, 330 insertions(+), 31 deletions(-)
 create mode 100644 src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala
 create mode 100644 src/dotty/tools/dotc/transform/PatternTypeFactorization.scala
 create mode 100644 tests/disabled/patternFactorization.scala
 rename tests/{run => disabled}/statics.scala (100%)

diff --git a/src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala b/src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala
new file mode 100644
index 000000000000..20256251c6ce
--- /dev/null
+++ b/src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala
@@ -0,0 +1,113 @@
+package dotty.tools.dotc
+package transform
+
+import TreeTransforms._
+import core.Contexts._
+import core.Constants._
+import dotty.tools.dotc.ast.tpd
+import ast.Trees._
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Contexts._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.core.Types._
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags
+import dotty.tools.dotc.core.Constants._
+import dotty.tools.dotc.core.Symbols._
+import dotty.tools.dotc.ast.Trees._
+import TreeTransforms._
+
+class PatternConstantsFactorization extends PatternFactorization {
+  import dotty.tools.dotc.ast.tpd._
+
+  def phaseName: String = "patternConstantsFactorization"
+
+  //override def runsAfter = Set(classOf[PatternTypeFactorization])
+
+  override def transformTry(tree: Try)(implicit ctx: Context, info: TransformerInfo): Tree = tree
+
+  protected def shouldSwap(caseDef1: CaseDef, caseDef2: CaseDef)(implicit ctx: Context): Boolean = {
+    (caseDef1.pat, caseDef2.pat) match {
+      case (Literal(const1), Literal(const2)) =>
+        if (const1 == const2) false
+        else const1.stringValue > const2.stringValue
+      case _ => false
+    }
+  }
+
+  protected def isOnConstant(caseDef: CaseDef): Boolean = caseDef match {
+    case CaseDef(Literal(Constant(_)), _, _) => true
+    case _                                   => false
+  }
+
+  protected def factorized(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): (List[List[CaseDef]], List[CaseDef]) = {
+    val reordered = reorderedCases(cases)
+    val preFactored = factorCases(reordered)
+    val (factoredConstants, fallbacks) =
+      preFactored.span(cases => isOnConstant(cases.head))
+    if (factoredConstants.nonEmpty) {
+      (factoredConstants, fallbacks.flatten)
+    } else {
+      val (fact, fallbacks1) = fallbacks.span(cases => !isOnConstant(cases.head))
+      if (fallbacks1.nonEmpty) (fact, fallbacks1.flatten)
+      else (Nil, fallbacks.flatten)
+    }
+  }
+
+  protected def asInnerMatchIfNeeded(sel: Symbol, caseDefs: List[CaseDef], fallbackOpt: Option[Tree])(implicit ctx: Context, info: TransformerInfo): CaseDef = {
+    assert(caseDefs.nonEmpty)
+    caseDefs.head match {
+      case caseDef @ CaseDef(Literal(_), EmptyTree, _) if caseDefs.size == 1 => caseDef
+      case CaseDef(lit @ Literal(_), _, _) =>
+        val fallbackCase = fallbackOpt.map(CaseDef(lit, EmptyTree, _))
+        asInnerMatchOnConstant(lit, caseDefs ++ fallbackCase)
+      case caseDef =>
+        val fallbackCase = fallbackOpt.map(CaseDef(Underscore(caseDef.pat.tpe.widen), EmptyTree, _))
+        asInnerMatch(caseDefs ++ fallbackCase)
+    }
+  }
+
+  protected def factorCases(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): List[List[CaseDef]] = {
+    def loop(remaining: List[CaseDef], groups: List[List[CaseDef]]): List[List[CaseDef]] = {
+      remaining match {
+        case CaseDef(lit @ Literal(_), _, _) :: _ =>
+          val (span, rest) = remaining.span {
+            case CaseDef(Literal(Constant(value)), _, _) => value == lit.const.value
+            case _ => false
+          }
+          loop(rest, span :: groups)
+
+        case _ :: _ =>
+          val (span, rest) = remaining.span {
+            case CaseDef(Literal(_), _, _) => false
+            case _ => true
+          }
+          loop(rest, span :: groups)
+
+        case Nil => groups.reverse
+      }
+    }
+    loop(cases, Nil)
+  }
+
+  protected def asInnerMatchOnConstant(lit: Literal, cases: List[CaseDef])(
+      implicit ctx: Context, info: TransformerInfo): CaseDef = {
+    val innerMatch = transformFollowing(Match(lit, cases))
+    CaseDef(lit, EmptyTree, innerMatch)
+  }
+
+  protected def asInnerMatch(cases: List[CaseDef])(
+    implicit ctx: Context, info: TransformerInfo): CaseDef = {
+    assert(cases.nonEmpty)
+    val tpe = cases.head.pat.tpe.widen
+    val selName = ctx.freshName("fact").toTermName
+    val factorizedSelector =
+      ctx.newSymbol(ctx.owner, selName, Flags.Synthetic | Flags.Case, tpe)
+    val selector = Ident(factorizedSelector.termRef)
+    val pattern = Bind(factorizedSelector, Underscore(factorizedSelector.info))
+    val innerMatch = transformFollowing(Match(selector, cases))
+    CaseDef(pattern, EmptyTree, innerMatch)
+  }
+}
diff --git a/src/dotty/tools/dotc/transform/PatternTypeFactorization.scala b/src/dotty/tools/dotc/transform/PatternTypeFactorization.scala
new file mode 100644
index 000000000000..a084a45e9de0
--- /dev/null
+++ b/src/dotty/tools/dotc/transform/PatternTypeFactorization.scala
@@ -0,0 +1,81 @@
+package dotty.tools.dotc
+package transform
+
+import TreeTransforms._
+import core.Contexts._
+import core.Symbols._
+import core.Types._
+import dotty.tools.dotc.core.DenotTransformers.DenotTransformer
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.{Flags, TypeApplications}
+import dotty.tools.dotc.typer.Applications
+import dotty.tools.dotc.util.Positions
+import typer.ErrorReporting._
+import ast.Trees._
+import Applications._
+import TypeApplications._
+import SymUtils._
+import core.NameOps._
+import core.Mode
+import dotty.tools.dotc.util.Positions.Position
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.Flags
+
+class PatternTypeFactorization extends PatternFactorization {
+  import dotty.tools.dotc.ast.tpd._
+
+  def phaseName: String = "patternTypeFactorization"
+
+  override def runsAfter = Set(classOf[TryCatchPatterns])
+
+  protected def shouldSwap(caseDef1: CaseDef, caseDef2: CaseDef)(implicit ctx: Context): Boolean = false && {
+    // fixme: this is wrong in case of primitives at least. run/matchbytes.scala demostrates this
+    val tpe1 = caseDef1.pat.tpe.widen
+    val tpe2 = caseDef2.pat.tpe.widen
+    tpe1.exists && tpe2.exists && !(tpe1 <:< tpe2) && !(tpe2 <:< tpe1) && tpe1.uniqId < tpe2.uniqId
+  }
+
+  protected def factorized(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): (List[List[CaseDef]], List[CaseDef]) = {
+    val reordered = reorderedCases(cases)
+    val preFactored = factorCases(reordered)
+    val (factoredTypes, fallbacks) = preFactored.span(hasCaseWithoutGuard)
+    if (fallbacks.nonEmpty) {
+      (factoredTypes :+ fallbacks.head, fallbacks.tail.flatten)
+    } else {
+      (factoredTypes, Nil)
+    }
+  }
+
+  protected def asInnerMatchIfNeeded(sel: Symbol, caseDefs: List[CaseDef], fallbackOpt: Option[Tree])(implicit ctx: Context, info: TransformerInfo): CaseDef = {
+    assert(caseDefs.nonEmpty)
+    val fallbackCase = fallbackOpt.map(CaseDef(Underscore(caseDefs.head.pat.tpe.widen), EmptyTree, _))
+    asInnerMatch(sel, caseDefs ++ fallbackCase)
+  }
+
+  protected def factorCases(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): List[List[CaseDef]] = {
+    def loop(remaining: List[CaseDef], groups: List[List[CaseDef]]): List[List[CaseDef]] = {
+      remaining match {
+        case c0 :: tail =>
+          val tpe = c0.pat.tpe.widen
+          val (span, rest) = tail.span(_.pat.tpe <:< tpe)
+          loop(rest, (c0 :: span) :: groups)
+
+        case Nil => groups.reverse
+      }
+    }
+    loop(cases, Nil)
+  }
+
+  protected def asInnerMatch(sel: Symbol, cases: List[CaseDef])(
+    implicit ctx: Context, info: TransformerInfo): CaseDef = {
+    assert(cases.nonEmpty)
+    val tpe = cases.head.pat.tpe.widen.orElse(sel.info.widen)
+    val selName = ctx.freshName("fact").toTermName
+    val factorizedSelector =
+      ctx.newSymbol(ctx.owner, selName, Flags.Synthetic | Flags.Case, tpe)
+    val selector = Ident(factorizedSelector.termRef)
+    val pattern = Bind(factorizedSelector, Typed(Underscore(factorizedSelector.info), TypeTree(factorizedSelector.info)))
+    val innerMatch = transformFollowing(Match(selector, cases))
+    CaseDef(pattern, EmptyTree, innerMatch)
+  }
+}
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 6d61c292571f..7d8031d09058 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -23,14 +23,6 @@ import scala.collection.mutable.ListBuffer
 
 
 class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
-  // todo: optimize patterns similar to
-  //       if fact27.ne(null) then
-  //         if fact27.exists.unary_! then
-  //           this.myUninstVars.+=(fact27)
-  //         else case701()
-  //       else case701()
-  // two ifs can be joined together
-
   import tpd._
 
   override def phaseName: String = "simplify"
@@ -73,9 +65,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       else false
     case Select(rec, _) if t.symbol.is(Flags.Method) =>
       if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
-      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName)
-        readingOnlyVals(rec) // accessing a field of a product
-      else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) {
+        def isImmutableField = {
+          val fieldId = t.symbol.name.drop(1).toString.toInt - 1
+          !t.symbol.owner.caseAccessors(ctx)(fieldId).is(Flags.Mutable)
+        }
+        if (isImmutableField) readingOnlyVals(rec) // accessing a field of a product
+        else false
+      } else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
         readingOnlyVals(rec)
       else false
     case Select(qual, _) if !t.symbol.is(Flags.Mutable) =>
@@ -170,9 +167,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         rollInArgs(argss.tail, tpd.New(a.tpe.dealias, argss.head))
       case a: Apply if a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
         (a.symbol.name == nme.unapply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
-        if (!a.symbol.owner.is(Flags.Scala2x))
-          a.args.head
-        else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
+        if (!a.symbol.owner.is(Flags.Scala2x)) {
+          if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
+          else a.args.head
+        } else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
           val accessors = a.args.head.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Flags.Method))
           val fields = accessors.map(x => a.args.head.select(x).ensureApplied)
           val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
@@ -286,22 +284,22 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
             if (l.const.booleanValue) l
             else Block(lhs :: Nil, rhs)
-          case (Literal(Constant(1)), _)    if sym == defn.Int_*  => rhs
-          case (Literal(Constant(0)), _)    if sym == defn.Int_+  => rhs
-          case (Literal(Constant(1L)), _)   if sym == defn.Long_* => rhs
-          case (Literal(Constant(0L)), _)   if sym == defn.Long_+ => rhs
-          // todo: same for float, double, short
-          // todo: empty string concat
-          // todo: disctribute & reorder constants
-          // todo: merge subsequent casts
-          case (_, Literal(Constant(1)))    if sym == defn.Int_/  => lhs
-          case (_, Literal(Constant(1L)))   if sym == defn.Long_/ => lhs
-          case (_, Literal(Constant(0)))    if sym == defn.Int_/  =>
-            Block(List(lhs),
-              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
-          case (_, Literal(Constant(0L)))  if sym == defn.Long_/ =>
-            Block(List(lhs),
-              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+//          case (Literal(Constant(1)), _)    if sym == defn.Int_*  => rhs
+//          case (Literal(Constant(0)), _)    if sym == defn.Int_+  => rhs
+//          case (Literal(Constant(1L)), _)   if sym == defn.Long_* => rhs
+//          case (Literal(Constant(0L)), _)   if sym == defn.Long_+ => rhs
+//          // todo: same for float, double, short
+//          // todo: empty string concat
+//          // todo: disctribute & reorder constants
+//          // todo: merge subsequent casts
+//          case (_, Literal(Constant(1)))    if sym == defn.Int_/  => lhs
+//          case (_, Literal(Constant(1L)))   if sym == defn.Long_/ => lhs
+//          case (_, Literal(Constant(0)))    if sym == defn.Int_/  =>
+//            Block(List(lhs),
+//              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+//          case (_, Literal(Constant(0L)))  if sym == defn.Long_/ =>
+//            Block(List(lhs),
+//              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
           case _ => t
         }
       case t: Match if (t.selector.tpe.isInstanceOf[ConstantType] && t.cases.forall(x => x.pat.tpe.isInstanceOf[ConstantType] || (tpd.isWildcardArg(x.pat) && x.guard.isEmpty))) =>
@@ -620,7 +618,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         defdef.rhs match {
           case Apply(t, args) if t.symbol.is(Flags.Label) &&
             TypeErasure.erasure(defdef.symbol.info.finalResultType).classSymbol == TypeErasure.erasure(t.symbol.info.finalResultType).classSymbol
-            && (args zip defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol)  && !(defdef.symbol eq t.symbol) =>
+            && args.size == defdef.vparamss.map(_.size).sum && (args zip defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol)  && !(defdef.symbol eq t.symbol) =>
               defined(defdef.symbol) = t.symbol
           case _ =>
         }
diff --git a/tests/disabled/patternFactorization.scala b/tests/disabled/patternFactorization.scala
new file mode 100644
index 000000000000..f92b20a5d1fd
--- /dev/null
+++ b/tests/disabled/patternFactorization.scala
@@ -0,0 +1,107 @@
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    val guard = true
+    (1) match {
+//      case 0 => println("0")
+//      case 1 => println("1")
+//      case 2 if guard => println("2")
+//      case 2 => println("3")
+//      case 3 => println("4")
+//      case 4 => println("5")
+      case 5 if guard => println("6")
+//      case _ if guard => println("7")
+      case _ => println("8")
+    }
+
+//    (1: Any) match {
+      //          case List(1, 2, 3) if guard => println("0")
+      //          case Some(x) => println("1")
+      //          case List(1, 2, 3) => println("2")
+      //          case List(1, 2) => println("3")
+      //          case 1 => println("4")
+      //          case 2 => println("5")
+      //          case x :: xs if guard => println("6")
+      //          case Nil => println("7")
+//      case 2 if true => 8
+//      case _: Int => 9
+      //          case 3 => println("10")
+      //          case Some(x) => println("11")
+      //          case None => println("12")
+//    }
+
+//    (1: Any) match {
+//                case List(1, 2, 3) => println("0")
+      //          case Some(x) => println("1")
+//                case List(1, 2, 3) => println("2")
+      //          case List(1, 2) => println("3")
+      //          case 1 => println("4")
+      //          case 2 => println("5")
+      //          case x :: xs if guard => println("6")
+      //          case Nil => println("7")
+//      case 2 if true => 8
+//      case _: Int => 9
+      //          case 3 => println("10")
+      //          case Some(x) => println("11")
+      //          case None => println("12")
+//    }
+////val guard = true
+//    (1) match {
+////      case List(a, b, c) => 4// 1
+////      case List(3, 4, 5) => 5// 2
+////      case Nil => // 2
+////      case List(3, 4, 5) => // 2
+////      case List(3, 4, 5) => // 2
+////      case x :: xs => // 2
+////      case Nil if true => 8
+////      case _: List[AnyRef] if true => 3
+////      case _: List[AnyRef] => 4
+////      case _: String if true => 5
+////      case _: Some => 6
+////      case _: String => 7
+//
+////      case 6 if false     => 2// 3
+////      case 6 if guard => 3// 3
+////
+////      case 8 =>       7      // 4
+////      case 2 if true =>   5           // 4
+////      case _ if false =>       33       // 5
+////      case 2 =>   8          // 4
+////      case n: Int if true =>       45       // 5
+////      case n: Int =>       46       // 5
+////      case n: Int if true =>       44       // 5
+//      case _ =>   1          // 4
+//
+////
+////      case List(3, 6, 5) => 5// 2
+////      case 3 =>       6      // 4
+////      case 7 =>       86      // 4
+////      case 5 if true =>       84      // 4
+////      case n2 =>       44       // 5
+////      case 3 => 2
+////      case 3L =>    4         // 4
+////      case Some(a) if a == "a" => 3// 4
+////      case None          =>4
+////      case 2L =>     4        // 4
+////      case List(a, b, c) =>4 // 1
+////      case 4 =>        4     // 4
+////      case _ =>    4         // 4
+////      case 4L =>             // 4
+////      case 1L =>             // 4
+////      case 4 if true =>             // 4
+////      case 4 if false =>             // 4
+////      case _: Int =>4
+////      case _ => 1
+////      case Some(a) if a == "b" => // 4
+////      case Some(a) if a == "a" => // 4
+////      case _ if true =>
+////      case Some(1)  => // 4
+////      case Some(a)       => // 4
+////      case None          =>
+////      case n1: Int if true =>             // 5
+////      case n2: Int if false =>             // 5
+////      case _: Int =>    44         // 5
+////      case _ =>       33       // 5
+//    }
+  }
+}
diff --git a/tests/run/statics.scala b/tests/disabled/statics.scala
similarity index 100%
rename from tests/run/statics.scala
rename to tests/disabled/statics.scala

From d16ad9ad5f1f3108e0f41cc5afff74612b599df7 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:46:53 +0200
Subject: [PATCH 25/88] simplify: Reading vals through successful casts should
 be allowed

---
 .../dotty/tools/dotc/core/Definitions.scala   | 10 +++
 .../dotc/transform/linker/Analysis.scala      | 71 +++++++++++++++++++
 .../dotc/transform/linker/Simplify.scala      |  3 +
 3 files changed, 84 insertions(+)
 create mode 100644 src/dotty/tools/dotc/transform/linker/Analysis.scala

diff --git a/compiler/src/dotty/tools/dotc/core/Definitions.scala b/compiler/src/dotty/tools/dotc/core/Definitions.scala
index a619c1a35dd3..e32e82f1e5da 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -399,6 +399,16 @@ class Definitions {
     def Boolean_&& = Boolean_andR.symbol
     lazy val Boolean_orR  = BooleanClass.requiredMethodRef(nme.ZOR)
     def Boolean_|| = Boolean_orR.symbol
+    lazy val Boolean_eqeqR = BooleanClass.info.member(nme.EQ).suchThat(_.info.firstParamTypes match {
+      case List(pt) => (pt isRef BooleanClass)
+      case _ => false
+    })
+    def Boolean_== = Boolean_eqeqR.symbol
+    lazy val Boolean_neqeqR = BooleanClass.info.member(nme.NE).suchThat(_.info.firstParamTypes match {
+      case List(pt) => (pt isRef BooleanClass)
+      case _ => false
+    })
+    def Boolean_!= = Boolean_neqeqR.symbol
 
   lazy val ByteType: TypeRef = valueTypeRef("scala.Byte", BoxedByteType, java.lang.Byte.TYPE, ByteEnc)
   def ByteClass(implicit ctx: Context) = ByteType.symbol.asClass
diff --git a/src/dotty/tools/dotc/transform/linker/Analysis.scala b/src/dotty/tools/dotc/transform/linker/Analysis.scala
new file mode 100644
index 000000000000..64c74f1009ce
--- /dev/null
+++ b/src/dotty/tools/dotc/transform/linker/Analysis.scala
@@ -0,0 +1,71 @@
+package dotty.tools.dotc.transform.linker
+
+import dotty.tools.dotc.{ast, core}
+import core._
+import Contexts._
+import dotty.tools.dotc.ast.Trees._
+import StdNames._
+import NameOps._
+import dotty.tools.dotc.ast.tpd
+import Symbols._
+import dotty.tools.dotc.core.Phases.Phase
+import dotty.tools.dotc.core.Types.{NoPrefix, TermRef, ThisType}
+import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
+import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
+import dotty.tools.dotc.transform.SymUtils._
+import Decorators._
+
+object Analysis {
+  import tpd._
+  private val constructorWhiteList = Set(
+    "scala.Tuple2",
+    "scala.Tuple3",
+    "scala.Tuple4",
+    "scala.Tuple5",
+    "scala.Tuple6",
+    "scala.Tuple7",
+    "scala.Tuple8",
+    "scala.Tuple9",
+    "scala.Tuple10",
+    "scala.Tuple11",
+    "scala.Tuple12",
+    "scala.Tuple13",
+    "scala.Tuple14",
+    "scala.Tuple15",
+    "scala.Tuple16",
+    "scala.Tuple17",
+    "scala.Tuple18",
+    "scala.Tuple19",
+    "scala.Tuple20",
+    "scala.Tuple21",
+    "scala.Tuple22",
+    "scala.Some"
+  )
+
+  private val methodsWhiteList = List(
+    "java.lang.Math.min",
+    "java.lang.Math.max",
+    "java.lang.Object.eq",
+    "java.lang.Object.ne",
+    "scala.Boolean.$amp$amp",
+    "scala.runtime.BoxesRunTime.unboxToBoolean",
+    "scala.runtime.BoxesRunTime.unboxToLong",
+    "scala.runtime.BoxesRunTime.unboxToInt",
+    "scala.runtime.BoxesRunTime.unboxToShort",
+    "scala.runtime.BoxesRunTime.unboxToDouble",
+    "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) =>
+        true
+      case Apply(fun, args) if methodsWhiteList.contains(fun.symbol.fullName.toString) =>
+        true
+      case _ =>
+        false
+      // analisys
+    }
+  }
+}
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 7d8031d09058..d846fac27135 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -56,6 +56,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private def readingOnlyVals(t: Tree)(implicit ctx: Context): Boolean = dropCasts(t) match {
     case Typed(exp, tpe) => readingOnlyVals(exp)
+    case TypeApply(fun @Select(rec, _), List(tp))
+      if (fun.symbol eq defn.Any_asInstanceOf) && rec.tpe.derivesFrom(TypeErasure.erasure(tp.tpe).classSymbol) =>
+      readingOnlyVals(rec)
     case Apply(Select(rec, _), Nil) =>
       if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
       else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName)

From b236b04c3927130b8227f73d93fd39b40eddb7d1 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:47:27 +0200
Subject: [PATCH 26/88] simplify: Playing with optimising if expressions.

Disabled it because it makes trees not similar
---
 .../dotc/transform/linker/Simplify.scala      | 43 ++++++++++++++++++-
 1 file changed, 42 insertions(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index d846fac27135..73036c878e06 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -174,11 +174,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
           else a.args.head
         } else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
+          // todo: if args is an expression, this will evaluate it multiple times
+          // todo: if the static type is right, it does not mean it's not null
           val accessors = a.args.head.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Flags.Method))
           val fields = accessors.map(x => a.args.head.select(x).ensureApplied)
           val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
 
-          if (!fields.tail.isEmpty) {
+          if (fields.tail.nonEmpty) {
             val tplAlloc = tpd.New(tplType, fields)
             tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
           } else { // scalac does not have tupple1
@@ -268,12 +270,37 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case If(t: Literal, thenp, elsep) =>
         if (t.const.booleanValue) thenp
         else elsep
+      case ift @ If(cond, thenp: Literal, elsep: Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && thenp.const.booleanValue && !elsep.const.booleanValue =>
+        if (thenp.const.booleanValue && !elsep.const.booleanValue) {
+          cond
+        }  else if (!thenp.const.booleanValue && elsep.const.booleanValue) {
+          cond.select(defn.Boolean_!).ensureApplied
+        } else ??? //should never happen becase it would be similar
+//         the lower two are disabled, as it may make the isSimilar rule not apply for a nested structure of iffs.
+//         see the example below:
+    //        (b1, b2) match {
+    //          case (true, true) => true
+    //          case (false, false) => true
+    //          case _ => false
+    //        }
+//      case ift @ If(cond, thenp: Literal, elsep) if ift.tpe.derivesFrom(defn.BooleanClass) && thenp.const.booleanValue =>
+//        //if (thenp.const.booleanValue)
+//          cond.select(defn.Boolean_||).appliedTo(elsep)
+//        //else // thenp is false, this tree is bigger then the original
+//        //  cond.select(defn.Boolean_!).select(defn.Boolean_&&).appliedTo(elsep)
+//      case ift @ If(cond, thenp, elsep :Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && !elsep.const.booleanValue =>
+//        cond.select(defn.Boolean_&&).appliedTo(elsep)
+//        // the other case ins't handled intentionally. See previous case for explanation
       case If(t@ Select(recv, _), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         tpd.If(recv, elsep, thenp)
       case If(t@ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         tpd.If(recv, elsep, thenp)
       // todo: similar trick for comparisons.
       // todo: handle comparison with min\max values
+      case Apply(meth1 @ Select(Apply(meth2 @ Select(rec, _), Nil), _), Nil) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! =>
+        rec
+      case meth1 @ Select(meth2 @ Select(rec, _), _) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! && !ctx.erasedTypes =>
+        rec
       case t@Apply(Select(lhs, _), List(rhs)) =>
         val sym = t.symbol
         (lhs, rhs) match {
@@ -283,6 +310,20 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
             if (const) Block(lhs :: Nil, rhs)
             else l
+
+          case (l, x: Literal) if sym == defn.Boolean_== && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+            if (x.const.booleanValue) l
+            else l.select(defn.Boolean_!).ensureApplied
+          case (l, x: Literal) if sym == defn.Boolean_!= && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+            if (!x.const.booleanValue) l
+            else l.select(defn.Boolean_!).ensureApplied
+          case (x: Literal, l) if sym == defn.Boolean_== && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+            if (x.const.booleanValue) l
+            else l.select(defn.Boolean_!).ensureApplied
+          case (x: Literal, l) if sym == defn.Boolean_!= && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+            if (!x.const.booleanValue) l
+            else l.select(defn.Boolean_!).ensureApplied
+
           case (l: Literal, _) if (sym == defn.Boolean_||) && l.tpe.isInstanceOf[ConstantType]   =>
             val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
             if (l.const.booleanValue) l

From dc75bd4ce3658b2adaa722a355ad4ae44e56ef02 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:48:41 +0200
Subject: [PATCH 27/88] simplify: fixes to inlineLocalObjects.

---
 .../dotc/transform/linker/Simplify.scala      | 28 +++++++++++++------
 1 file changed, 19 insertions(+), 9 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 73036c878e06..7acb8ef652ef 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -106,12 +106,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ,inlineLabelsCalledOnce
     ,devalify
     ,jumpjump
+    ,dropGoodCasts
     ,dropNoEffects
-//    ,inlineLocalObjects // followCases needs to be fixed, see ./tests/pos/rbtree.scala
+    ,inlineLocalObjects // followCases needs to be fixed, see ./tests/pos/rbtree.scala
     /*, varify*/  // varify could stop other transformations from being applied. postponed.
     //, bubbleUpNothing
     ,constantFold
   )
+
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     val ctx0 = ctx
     if (!tree.symbol.is(Flags.Label)) {
@@ -386,7 +388,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
     }
     val visitor: Visitor = {
-      case vdef: ValDef if vdef.symbol.info.classSymbol is Flags.CaseClass  =>
+      case vdef: ValDef if (vdef.symbol.info.classSymbol is Flags.CaseClass) && !vdef.symbol.is(Flags.Lazy)  =>
         followTailPerfect(vdef.rhs, vdef.symbol)
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
         checkGood.put(rhs.symbol, lhs.symbol)
@@ -399,7 +401,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case _ =>
     }
 
-    val transformer: Transformer = () => localCtx => {
+    val transformer: Transformer = () => {
       var hasChanged = true
       while(hasChanged) {
         hasChanged = false
@@ -413,12 +415,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       val newMappings: Map[Symbol, Map[Symbol, Symbol]] =
         hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Flags.Method) && !x.is(Flags.Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is Flags.CaseClass))
           .map{ refVal =>
-            val fields = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
+//          println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
+          val fields = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
           val productAccessors = (1 to fields.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // todo: disambiguate
           val newLocals = fields.map(x =>
             // todo: it would be nice to have an additional optimization that
             // todo: is capable of turning those mutable ones into immutable in common cases
-            ctx.newSymbol(refVal.owner, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
+            ctx.newSymbol(ctx.owner.enclosingMethod, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
           )
             val fieldMapping = fields zip newLocals
             val productMappings = productAccessors zip newLocals
@@ -432,7 +435,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case tree@ If(_, thenp, elsep) => cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
           case Apply(sel , args) if sel.symbol.isConstructor && t.tpe.widenDealias == target.info.widenDealias.finalResultType.widenDealias =>
             val fieldsByAccessors = newMappings(target)
-            val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
+            val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)  // todo: when is this filter needed?
             val assigns = (accessors zip args) map (x => ref(fieldsByAccessors(x._1)).becomes(x._2))
             val recreate = sel.appliedToArgs(accessors.map(x => ref(fieldsByAccessors(x))))
             Block(assigns, recreate)
@@ -464,7 +467,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         followCases(checkGood.getOrElse(t, NoSymbol))
       } else t
 
-      { (t: Tree) => t match {
+      hasPerfectRHS.clear()
+      //checkGood.clear()
+      gettersCalled.clear()
+
+      val res: Context => Tree => Tree = {localCtx => (t: Tree) => t match {
         case ddef: DefDef if ddef.symbol.is(Flags.Label) =>
           newMappings.get(followCases(ddef.symbol)) match {
             case Some(mappings) =>
@@ -476,7 +483,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           // break ValDef apart into fields + boxed value
           val newFields = newMappings(a.symbol).values.toSet
           Thicket(
-            newFields.map(x => tpd.ValDef(x.asTerm, EmptyTree)).toList :::
+            newFields.map(x => tpd.ValDef(x.asTerm, tpd.defaultValue(x.symbol.info.widenDealias))).toList :::
               List(cpy.ValDef(a)(rhs = splitWrites(a.rhs, a.symbol))))
         case ass: Assign =>
           newMappings.get(ass.lhs.symbol) match {
@@ -493,7 +500,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             case Some(newSym) => ref(newSym)
           }
         case t => t
-      }}}
+      }}
+
+    res
+    }
     ("inlineLocalObjects", BeforeAndAfterErasure, visitor, transformer)
   }}
 

From aa854ec35b77af677e017159a975049ccb53d443 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:49:07 +0200
Subject: [PATCH 28/88] Simplify: add vilify transformation

---
 .../dotc/transform/linker/Simplify.scala      | 72 +++++++++++++++++++
 1 file changed, 72 insertions(+)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 7acb8ef652ef..4c823fe1e56d 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -104,6 +104,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     inlineCaseIntrinsics
     ,inlineOptions
     ,inlineLabelsCalledOnce
+    ,valify
     ,devalify
     ,jumpjump
     ,dropGoodCasts
@@ -745,6 +746,77 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
   }}
 
+  val valify: Optimization = { (ctx0: Context) => {
+    implicit val ctx: Context = ctx0
+     // either a duplicate or a read through series of immutable fields
+    val defined: mutable.Map[Symbol, ValDef] = mutable.Map()
+    val firstRead: mutable.Map[Symbol, RefTree] = mutable.Map()
+    val firstWrite: mutable.Map[Symbol, Assign] = mutable.Map()
+    val secondWrite: mutable.Map[Symbol, Assign] = mutable.Map()
+    val visitor: Visitor = {
+      case t: ValDef if t.symbol.is(Flags.Mutable, Flags.Lazy) && !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
+        if (tpd.isPureExpr(t.rhs))
+          defined(t.symbol) = t
+      case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
+        if (!firstWrite.contains(t.symbol)) firstRead(t.symbol) = t
+      case t @ Assign(l, expr) if  !l.symbol.is(Flags.Method) && !l.symbol.owner.isClass =>
+        if (!firstRead.contains(l.symbol)) {
+          if (firstWrite.contains(l.symbol)) {
+            if (!secondWrite.contains(l.symbol))
+              secondWrite(l.symbol) = t
+          } else if (!expr.existsSubTree(x => x match {
+            case tree: RefTree if x.symbol == l.symbol => firstRead(l.symbol) = tree; true
+            case _ => false
+          })) {
+            firstWrite(l.symbol) = t
+          }
+        }
+      case _ =>
+    }
+
+    val transformer: Transformer = () => localCtx => {
+      val transformation: Tree => Tree = {
+        case t: Block => // drop non-side-effecting stats
+          val valdefs = t.stats.filter(x => x match  {
+            case t: ValDef if defined.contains(t.symbol) => true
+            case _ => false
+          }).asInstanceOf[List[ValDef]]
+          val assigns = t.stats.filter(x => x match {
+            case t @ Assign(lhs, r) =>
+              firstWrite.contains(lhs.symbol) && !secondWrite.contains(lhs.symbol)
+            case _ => false
+          })
+
+          val pairs = valdefs.flatMap(x => assigns.find(y => y.asInstanceOf[Assign].lhs.symbol == x.symbol) match {
+            case Some(y: Assign) => List((x, y))
+            case _ => Nil
+          })
+
+          val valsToDrop = pairs.map(x => x._1).toSet
+          val assignsToReplace: Map[Assign, ValDef] = pairs.map(x => (x._2, x._1)).toMap
+
+          val newStats = t.stats.mapConserve {
+            case x: ValDef if valsToDrop.contains(x) => EmptyTree
+            case t: Assign => assignsToReplace.get(t) match {
+              case Some(vd) =>
+                val newD = vd.symbol.asSymDenotation.copySymDenotation(initFlags = vd.symbol.flags.&~(Flags.Mutable))
+                newD.installAfter(this)
+                tpd.ValDef(vd.symbol.asTerm, t.rhs)
+              case None => t
+            }
+            case x => x
+          }
+
+          if (newStats eq t.stats) t
+          else cpy.Block(t)(newStats, t.expr)
+        case tree => tree
+      }
+
+      transformation
+    }
+    ("valify", BeforeAndAfterErasure, visitor, transformer)
+  }}
+
   val devalify: Optimization = { (ctx0: Context) => {
     implicit val ctx: Context = ctx0
     val timesUsed = collection.mutable.HashMap[Symbol, Int]()

From ae35fb75596ac9c195b44d5c6e4698b44cf245dc Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:50:23 +0200
Subject: [PATCH 29/88] Simplify: add dropGoodCasts that drops good casts in
 stat position.

---
 .../dotc/transform/linker/Simplify.scala      | 44 +++++++++++++++++++
 1 file changed, 44 insertions(+)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 4c823fe1e56d..20a7fe79b6b2 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -508,6 +508,50 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ("inlineLocalObjects", BeforeAndAfterErasure, visitor, transformer)
   }}
 
+  private def collectTypeTests(t: Tree)(implicit ctx: Context): List[(Symbol, Type)] = {
+    def recur(t: Tree): List[(Symbol, Type)] =
+      t match {
+        case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
+        case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
+        case TypeApply(fun @Select(x, _), List(tp)) if fun.symbol eq defn.Any_isInstanceOf =>
+          if (!x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
+            (x.symbol, tp.tpe) :: Nil
+          else Nil
+        case _ => List.empty
+      }
+    recur(t)
+  }
+
+  val dropGoodCasts: Optimization = { (ctx0: Context) => {
+    implicit val ctx: Context = ctx0
+
+    val transformer: Transformer = () => localCtx => {
+      case t @ If(cond, thenp, elsep) =>
+        val newTested = collectTypeTests(cond)
+        val testedMap = newTested.foldRight[Map[Symbol, List[Type]]](Map.empty)((x, y) =>
+          y + ((x._1, x._2 :: y.getOrElse(x._1, Nil)))
+        )
+        val dropGoodCastsInStats = new TreeMap() {
+          override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = super.transform(tree) match {
+            case t: Block =>
+              val nstats = t.stats.filterConserve({
+                 case TypeApply(fun @ Select(rec, _), List(tp)) if fun.symbol == defn.Any_asInstanceOf =>
+                   !testedMap.getOrElse(rec.symbol, Nil).exists(x => x <:< tp.tpe)
+                 case _ => true
+              })
+              if (nstats eq t.stats) t
+              else Block(nstats, t.expr)
+            case t => t
+          }
+        }
+        val nthenp = dropGoodCastsInStats.transform(thenp)
+
+        cpy.If(t)(thenp = nthenp, elsep = elsep)
+      case t => t
+    }
+    ("dropGoodCasts", BeforeAndAfterErasure, NoVisitor, transformer)
+  }}
+
   private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
     t match {
       case t: Literal => EmptyTree

From 646f11a57e2800002b693fcb932b046f2fe52e18 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:50:38 +0200
Subject: [PATCH 30/88] Simplify: fix the fix of handling by-name arguments.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 20a7fe79b6b2..f39c383b2700 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -579,7 +579,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
         cpy.Block(bl)(stats2, expr2)
-      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) && t.tpe.isInstanceOf[ExprType] =>
+      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
         desugarIdent(t) match {
           case Some(t) => t
           case None => EmptyTree

From a1ad54cf69429c9edce9dfd4929e4e84ee725cc8 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:51:06 +0200
Subject: [PATCH 31/88] Simplify: dropNoEffects now flattens blocks.

---
 .../tools/dotc/transform/linker/Simplify.scala  | 17 +++++++++++++----
 1 file changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index f39c383b2700..305844168eea 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -654,10 +654,19 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val transformer: Transformer = () => localCtx => {
       case Block(Nil, expr) => expr
       case a: Block  =>
-        val newStats = a.stats.mapConserve(keepOnlySideEffects)
-        if (newStats.nonEmpty)
-          cpy.Block(a)(stats = newStats, a.expr)
-        else a.expr
+        val newStats0 = a.stats.mapConserve(keepOnlySideEffects)
+        val newStats1 = if (newStats0 eq a.stats) newStats0 else newStats0.flatMap{
+          case x: Block=> x.stats ::: List(x.expr)
+          case EmptyTree => Nil
+          case t => t :: Nil
+        }
+        val (newStats2, newExpr) = a.expr match {
+          case Block(stats2, expr) => (newStats1 ++ stats2, expr)
+          case _ => (newStats1, a.expr)
+        }
+        if (newStats2.nonEmpty)
+          cpy.Block(a)(stats = newStats2, newExpr)
+        else newExpr
       case a: DefDef =>
         if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
           def insertUnit(t: Tree) = {

From c6f0e8d82a1b41a249daeab1967b9d4276257881 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:51:35 +0200
Subject: [PATCH 32/88] Simplify: inline case-defs that have literal in rhs.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 305844168eea..66c36792bd3b 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -697,12 +697,16 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
 
     val transformer: Transformer = () => localCtx => {
-      case a: Apply if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramTypess == List(Nil)=>
+      case a: Apply =>
         defined.get(a.symbol) match {
           case None => a
-          case Some(defDef) =>
+          case Some(defDef) if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramTypess == List(Nil)=>
             //println(s"Inlining ${defDef.name}")
             defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
+          case Some(defDef) if defDef.rhs.isInstanceOf[Literal] =>
+            defDef.rhs
+          case Some(_) =>
+            a
         }
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
         //println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")

From 05a538298195973346cf1b1723850a0c3d3995da Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 2 Sep 2016 15:52:05 +0200
Subject: [PATCH 33/88] Simplify: Somes\options can be null :-(

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 66c36792bd3b..e4d5781c04a9 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -775,19 +775,19 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case Select(rec, nm) if nm == nme.get && somes.contains(rec.symbol) =>
           somes(rec.symbol)
         case Select(rec, nm) if nm == nme.isDefined &&
-          (rec.tpe.derivesFrom(defn.SomeClass) || somes.contains(rec.symbol)) =>
+          (/*rec.tpe.derivesFrom(defn.SomeClass) ||*/ somes.contains(rec.symbol)) =>
           Literal(Constant(true))
         case Select(rec, nm) if nm == nme.isEmpty &&
-          (rec.tpe.derivesFrom(defn.SomeClass) || somes.contains(rec.symbol)) =>
+          (/*rec.tpe.derivesFrom(defn.SomeClass) ||*/ somes.contains(rec.symbol)) =>
           Literal(Constant(false))
 
         case Select(rec, nm) if nm == nme.get && nones.contains(rec.symbol) =>
           ref(defn.NoneModuleRef)
         case Select(rec, nm) if nm == nme.isDefined &&
-          (rec.tpe.derivesFrom(defn.NoneClass) || nones.contains(rec.symbol)) =>
+          (/*rec.tpe.derivesFrom(defn.NoneClass) || */ nones.contains(rec.symbol)) =>
           Literal(Constant(false))
         case Select(rec, nm) if nm == nme.isEmpty &&
-          (rec.tpe.derivesFrom(defn.NoneClass) || nones.contains(rec.symbol)) =>
+          (/*rec.tpe.derivesFrom(defn.NoneClass) ||*/ nones.contains(rec.symbol)) =>
           Literal(Constant(true))
         case t => t
       }

From e93dd61f9b5176d6f6b4b3431a4568f0c1caf3ee Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 14:49:32 +0200
Subject: [PATCH 34/88] Make optimisation optional.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 4 +++-
 tests/{run => disabled}/i1144/AB_1.scala             | 0
 tests/{run => disabled}/i1144/C_2.scala              | 0
 tests/{run => disabled}/redundantParents.scala       | 0
 4 files changed, 3 insertions(+), 1 deletion(-)
 rename tests/{run => disabled}/i1144/AB_1.scala (100%)
 rename tests/{run => disabled}/i1144/C_2.scala (100%)
 rename tests/{run => disabled}/redundantParents.scala (100%)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index e4d5781c04a9..dada563b502e 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -29,12 +29,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private var SeqFactoryClass: Symbol = null
   private var symmetricOperations: Set[Symbol] = null
+  var optimize = false
 
 
 
   override def prepareForUnit(tree: _root_.dotty.tools.dotc.ast.tpd.Tree)(implicit ctx: Context): TreeTransform = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
     symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
+    optimize = ctx.settings.optimise.value
     this
   }
 
@@ -117,7 +119,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
     val ctx0 = ctx
-    if (!tree.symbol.is(Flags.Label)) {
+    if (optimize && !tree.symbol.is(Flags.Label)) {
       implicit val ctx: Context = ctx0.withOwner(tree.symbol(ctx0))
       // TODO: optimize class bodies before erasure?
       var rhs0 = tree.rhs
diff --git a/tests/run/i1144/AB_1.scala b/tests/disabled/i1144/AB_1.scala
similarity index 100%
rename from tests/run/i1144/AB_1.scala
rename to tests/disabled/i1144/AB_1.scala
diff --git a/tests/run/i1144/C_2.scala b/tests/disabled/i1144/C_2.scala
similarity index 100%
rename from tests/run/i1144/C_2.scala
rename to tests/disabled/i1144/C_2.scala
diff --git a/tests/run/redundantParents.scala b/tests/disabled/redundantParents.scala
similarity index 100%
rename from tests/run/redundantParents.scala
rename to tests/disabled/redundantParents.scala

From ae9a562a9807316677762c0c356d57e96e6c0e08 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 14:51:29 +0200
Subject: [PATCH 35/88] Simplify:inlineLocalObjects: don't inline mutable
 fields.

---
 .../tools/dotc/transform/linker/Simplify.scala     | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index dada563b502e..4998c7f120f3 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -391,7 +391,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
     }
     val visitor: Visitor = {
-      case vdef: ValDef if (vdef.symbol.info.classSymbol is Flags.CaseClass) && !vdef.symbol.is(Flags.Lazy)  =>
+      case vdef: ValDef if (vdef.symbol.info.classSymbol is Flags.CaseClass) && !vdef.symbol.is(Flags.Lazy)  && !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Flags.Mutable)) =>
         followTailPerfect(vdef.rhs, vdef.symbol)
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
         checkGood.put(rhs.symbol, lhs.symbol)
@@ -419,14 +419,15 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Flags.Method) && !x.is(Flags.Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is Flags.CaseClass))
           .map{ refVal =>
 //          println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
-          val fields = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
-          val productAccessors = (1 to fields.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // todo: disambiguate
-          val newLocals = fields.map(x =>
+          var accessors = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
+          if (accessors.isEmpty) accessors = refVal.info.classSymbol.caseAccessors
+          val productAccessors = (1 to accessors.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // todo: disambiguate
+          val newLocals = accessors.map(x =>
             // todo: it would be nice to have an additional optimization that
             // todo: is capable of turning those mutable ones into immutable in common cases
             ctx.newSymbol(ctx.owner.enclosingMethod, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
           )
-            val fieldMapping = fields zip newLocals
+            val fieldMapping = accessors zip newLocals
             val productMappings = productAccessors zip newLocals
             (refVal, (fieldMapping ++ productMappings).toMap)
           }.toMap
@@ -438,7 +439,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case tree@ If(_, thenp, elsep) => cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
           case Apply(sel , args) if sel.symbol.isConstructor && t.tpe.widenDealias == target.info.widenDealias.finalResultType.widenDealias =>
             val fieldsByAccessors = newMappings(target)
-            val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)  // todo: when is this filter needed?
+            var accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)  // todo: when is this filter needed?
+            if (accessors.isEmpty) accessors = target.info.classSymbol.caseAccessors
             val assigns = (accessors zip args) map (x => ref(fieldsByAccessors(x._1)).becomes(x._2))
             val recreate = sel.appliedToArgs(accessors.map(x => ref(fieldsByAccessors(x))))
             Block(assigns, recreate)

From 14bc530106e74e8ec0531057bfd578a1037cb516 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 14:52:31 +0200
Subject: [PATCH 36/88] Simplify: DropGoodCasts: Don't accumulate cast on
 garbage.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 4998c7f120f3..efe3401d15c3 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -518,7 +518,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
         case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
         case TypeApply(fun @Select(x, _), List(tp)) if fun.symbol eq defn.Any_isInstanceOf =>
-          if (!x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
+          if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
             (x.symbol, tp.tpe) :: Nil
           else Nil
         case _ => List.empty

From a8c9e9414f19950d651c1bed98b2270fac6d18f2 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 14:52:53 +0200
Subject: [PATCH 37/88] Simplify: devalify: correctly rebase New when prefix
 changes.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index efe3401d15c3..35f99f55899d 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -947,6 +947,17 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           EmptyTree
         case t: Block => // drop non-side-effecting stats
           t
+        case t: New =>
+          val symIfExists = t.tpt.tpe.normalizedPrefix.termSymbol
+          if (replacements.contains(symIfExists)) {
+            val newPrefix = deepReplacer.transform(replacements(symIfExists))
+            val newTpt = t.tpt.tpe match {
+              case t: NamedType =>
+                t.derivedSelect(newPrefix.tpe)
+            }
+            tpd.New(newTpt)
+          }
+          else t
         case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.is(Flags.Param) && !t.symbol.is(Flags.Mutable) =>
           if (replacements.contains(t.symbol))
             deepReplacer.transform(replacements(t.symbol)).ensureConforms(t.tpe.widen)

From 6536d8fc58f6aa16516d4f40b705a6ce9200bcb1 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 16:47:40 +0200
Subject: [PATCH 38/88] Simplify:inlineLocalObjects: make more robust against
 complex labels.

---
 .../dotc/transform/linker/Simplify.scala      | 21 ++++++++++++-------
 1 file changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 35f99f55899d..f17ab01c086c 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -375,7 +375,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   val inlineLocalObjects: Optimization = { (ctx0: Context) => {
     implicit val ctx: Context = ctx0
     val hasPerfectRHS = collection.mutable.HashMap[Symbol, Boolean]() // in the end only calls constructor. Reason for unconditional inlining
-    val checkGood = collection.mutable.HashMap[Symbol, Symbol]() // if key has perfect RHS than value has perfect RHS
+    val checkGood = collection.mutable.HashMap[Symbol, Set[Symbol]]() // if all values have perfect RHS than key has perfect RHS
+    val forwarderWritesTo = collection.mutable.HashMap[Symbol, Symbol]()
     val gettersCalled = collection.mutable.HashSet[Symbol]()
     def followTailPerfect(t: Tree, symbol: Symbol): Unit = {
       t match {
@@ -384,9 +385,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case Apply(fun, _) if fun.symbol.isConstructor && t.tpe.widenDealias == symbol.info.widenDealias.finalResultType.widenDealias =>
           hasPerfectRHS(symbol) = true
         case Apply(fun, _) if fun.symbol.is(Flags.Label) && (fun.symbol ne symbol) =>
-          checkGood.put(fun.symbol, symbol)
+          checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + fun.symbol)
+          assert(forwarderWritesTo.getOrElse(t.symbol, symbol) == symbol)
+          forwarderWritesTo(t.symbol) = symbol
         case t: Ident if !t.symbol.owner.isClass && (t.symbol ne symbol) =>
-          checkGood.put(t.symbol, symbol)
+          checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + t.symbol)
         case _ =>
       }
     }
@@ -394,7 +397,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case vdef: ValDef if (vdef.symbol.info.classSymbol is Flags.CaseClass) && !vdef.symbol.is(Flags.Lazy)  && !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Flags.Mutable)) =>
         followTailPerfect(vdef.rhs, vdef.symbol)
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
-        checkGood.put(rhs.symbol, lhs.symbol)
+        checkGood.put(lhs.symbol, checkGood.getOrElse(lhs.symbol, Set.empty) + rhs.symbol)
       case t @ Select(qual, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
         (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.maybeOwner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
         (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
@@ -408,9 +411,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       var hasChanged = true
       while(hasChanged) {
         hasChanged = false
-        checkGood.foreach{case (key, value) =>
-          if (hasPerfectRHS.getOrElse(key, false)) {
-            hasChanged = !hasPerfectRHS.put(value, true).getOrElse(false)
+        checkGood.foreach{case (key, values) =>
+          values.foreach { value =>
+            if (hasPerfectRHS.getOrElse(key, false)) {
+              hasChanged = !hasPerfectRHS.put(value, true).getOrElse(false)
+            }
           }
         }
       }
@@ -469,7 +474,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       def followCases(t: Symbol): Symbol = if (t.symbol.is(Flags.Label)) {
         // todo: this can create cycles, see ./tests/pos/rbtree.scala
-        followCases(checkGood.getOrElse(t, NoSymbol))
+        followCases(forwarderWritesTo.getOrElse(t.symbol, NoSymbol))
       } else t
 
       hasPerfectRHS.clear()

From 2b3d0d2846a4acfc1d56a8001d39031b873d6c30 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 16:49:18 +0200
Subject: [PATCH 39/88] Simplify: NullCheck: as proposed by @jvican

---
 .../dotc/transform/linker/Simplify.scala      | 46 +++++++++++++++++++
 1 file changed, 46 insertions(+)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index f17ab01c086c..44eb37824924 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -638,6 +638,52 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
   }
 
+  val removeUnnecessaryNullChecks: Optimization = { (ctx0: Context) => {
+    implicit val ctx = ctx0
+    val initializedVals = mutable.HashSet[Symbol]()
+    val visitor: Visitor = {
+      case vd: ValDef =>
+        val rhs = vd.rhs
+        val rhsName = rhs.symbol.name
+        if (!vd.symbol.is(Flags.Mutable) &&
+          !rhs.isEmpty || rhsName != nme.WILDCARD || rhsName !=
+          nme.???) {
+          initializedVals += vd.symbol
+        }
+      case t: Tree =>
+    }
+    @inline def isLhsNullLiteral(t: Tree) = t match {
+      case Select(literalLhs: Literal, _) =>
+        literalLhs.const.tag == Constants.NullTag
+      case _ => false
+    }
+    @inline def isRhsNullLiteral(args: List[Tree]) = args match {
+      case List(booleanRhs: Literal) =>
+        booleanRhs.const.tag == Constants.NullTag
+      case _ => false
+    }
+    val transformer: Transformer = () => localCtx0 => {
+      implicit val localCtx = localCtx0
+      val transformation: Tree => Tree = {
+        case potentialCheck: Apply =>
+          val sym = potentialCheck.symbol
+          if (isLhsNullLiteral(potentialCheck.fun)) {
+            if (sym == defn.Boolean_==) tpd.Literal(Constant(true))
+            else if(sym == defn.Boolean_!=) tpd.Literal(Constant(false))
+            else potentialCheck
+          } else if (isRhsNullLiteral(potentialCheck.args)) {
+            if (sym == defn.Boolean_==) tpd.Literal(Constant(true))
+            else if(sym == defn.Boolean_!=) tpd.Literal(Constant(false))
+            else potentialCheck
+          } else potentialCheck
+        case t => t
+      }
+      transformation
+    }
+    ("removeUnnecessaryNullChecks", BeforeAndAfterErasure, visitor,
+      transformer)
+  }}
+
   val bubbleUpNothing: Optimization = { (ctx0: Context) => {
     implicit val ctx: Context = ctx0
     val transformer: Transformer = () => localCtx => {

From 8fb95546ae24dd063cdcf3ddcdf2658adc571be0 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 6 Sep 2016 18:12:47 +0200
Subject: [PATCH 40/88] Simplify: fix and enable removeUnnecessaryNullChecks.

---
 .../dotc/transform/linker/Simplify.scala      | 74 +++++++++++++------
 1 file changed, 50 insertions(+), 24 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 44eb37824924..df7f17f6ffca 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -104,6 +104,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private lazy val _optimizations: Seq[Optimization] = Seq(
     inlineCaseIntrinsics
+    ,removeUnnecessaryNullChecks
     ,inlineOptions
     ,inlineLabelsCalledOnce
     ,valify
@@ -639,43 +640,68 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }
 
   val removeUnnecessaryNullChecks: Optimization = { (ctx0: Context) => {
-    implicit val ctx = ctx0
+    implicit val ctx: Context = ctx0
     val initializedVals = mutable.HashSet[Symbol]()
+    val checkGood = mutable.HashMap[Symbol, Set[Symbol]]()
+    def isGood(t: Symbol) = {
+      t.exists && initializedVals.contains(t) && {
+        var changed = true
+        var set = Set(t)
+        while (changed) {
+          val oldSet = set
+          set = set ++ set.flatMap(x => checkGood.getOrElse(x, Nil))
+          changed = set != oldSet
+        }
+        !set.exists(x => !initializedVals.contains(x))
+      }
+
+    }
     val visitor: Visitor = {
       case vd: ValDef =>
         val rhs = vd.rhs
         val rhsName = rhs.symbol.name
         if (!vd.symbol.is(Flags.Mutable) &&
-          !rhs.isEmpty || rhsName != nme.WILDCARD || rhsName !=
-          nme.???) {
-          initializedVals += vd.symbol
+          !rhs.isEmpty) {
+
+          def checkNonNull(t: Tree, target: Symbol): Boolean = t match {
+            case Block(_ , expr) => checkNonNull(expr, target)
+            case If(_, thenp, elsep) => checkNonNull(thenp, target) && checkNonNull(elsep, target)
+            case t: New => true
+            case t: Apply if t.symbol.isPrimaryConstructor => true
+            case t: Literal => t.const.value != null
+            case t: This => true
+            case t: Ident if !t.symbol.owner.isClass =>
+              checkGood.put(target, checkGood.getOrElse(target, Set.empty) + t.symbol)
+              true
+            case t: Apply if !t.symbol.owner.isClass =>
+              checkGood.put(target, checkGood.getOrElse(target, Set.empty) + t.symbol)
+              true
+            case t: Typed =>
+              checkNonNull(t.expr, target)
+            case _ => t.tpe.isNotNull
+          }
+          if (checkNonNull(vd.rhs, vd.symbol))
+            initializedVals += vd.symbol
         }
       case t: Tree =>
     }
-    @inline def isLhsNullLiteral(t: Tree) = t match {
-      case Select(literalLhs: Literal, _) =>
-        literalLhs.const.tag == Constants.NullTag
-      case _ => false
-    }
-    @inline def isRhsNullLiteral(args: List[Tree]) = args match {
-      case List(booleanRhs: Literal) =>
-        booleanRhs.const.tag == Constants.NullTag
+
+    @inline def isNullLiteral(tree: Tree) = tree match {
+      case literal: Literal =>
+        literal.const.tag == Constants.NullTag
       case _ => false
     }
     val transformer: Transformer = () => localCtx0 => {
-      implicit val localCtx = localCtx0
+      implicit val ctx: Context = localCtx0
       val transformation: Tree => Tree = {
-        case potentialCheck: Apply =>
-          val sym = potentialCheck.symbol
-          if (isLhsNullLiteral(potentialCheck.fun)) {
-            if (sym == defn.Boolean_==) tpd.Literal(Constant(true))
-            else if(sym == defn.Boolean_!=) tpd.Literal(Constant(false))
-            else potentialCheck
-          } else if (isRhsNullLiteral(potentialCheck.args)) {
-            if (sym == defn.Boolean_==) tpd.Literal(Constant(true))
-            else if(sym == defn.Boolean_!=) tpd.Literal(Constant(false))
-            else potentialCheck
-          } else potentialCheck
+        case check@Apply(Select(lhs, _), List(rhs)) =>
+          val sym = check.symbol
+          if ( ((sym == defn.Object_eq) || (sym == defn.Object_ne)) &&
+            ((isNullLiteral(lhs) && isGood(rhs.symbol)) || (isNullLiteral(rhs) && isGood(lhs.symbol)))) {
+            if (sym == defn.Object_eq) Block(List(lhs, rhs), tpd.Literal(Constant(false)))
+            else if(sym == defn.Object_ne) Block(List(lhs, rhs), tpd.Literal(Constant(true)))
+            else check
+          } else check
         case t => t
       }
       transformation

From 9314e91cc051ce24b7eec8d447cd0a1ce056e699 Mon Sep 17 00:00:00 2001
From: jvican <jorgevc@fastmail.es>
Date: Wed, 7 Sep 2016 22:50:01 +0200
Subject: [PATCH 41/88] Add missing NamedType import

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index df7f17f6ffca..bfb4aa21c3f0 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -9,7 +9,7 @@ import NameOps._
 import dotty.tools.dotc.ast.tpd
 import Symbols._
 import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.core.Types.{ConstantType,ExprType, MethodType, MethodicType, NoPrefix, NoType, TermRef, ThisType, Type}
+import dotty.tools.dotc.core.Types.{ConstantType, ExprType, MethodType, MethodicType, NamedType, NoPrefix, NoType, TermRef, ThisType, Type}
 import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
 import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
 import dotty.tools.dotc.transform.SymUtils._

From 02be44bfbad859f9e6bb568964a1f65f43ec1763 Mon Sep 17 00:00:00 2001
From: jvican <jorgevc@fastmail.es>
Date: Wed, 7 Sep 2016 23:49:20 +0200
Subject: [PATCH 42/88] Simplify: devalify: don't kick in on by-name params

The previous optimization was kicking in even if the parameter was by-name. This is problematic because by-name params can be side-effectful. These changes fix colltest4 run tests.
---
 src/dotty/tools/dotc/transform/linker/Simplify.scala |  2 +-
 tests/run/byname-param.check                         |  3 +++
 tests/run/byname-param.scala                         | 12 ++++++++++++
 3 files changed, 16 insertions(+), 1 deletion(-)
 create mode 100644 tests/run/byname-param.check
 create mode 100644 tests/run/byname-param.scala

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index bfb4aa21c3f0..202d25447015 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -82,7 +82,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       else false
     case Select(qual, _) if !t.symbol.is(Flags.Mutable) =>
       readingOnlyVals(qual)
-    case t: Ident if !t.symbol.is(Flags.Mutable) && !t.symbol.is(Flags.Method) =>
+    case t: Ident if !t.symbol.is(Flags.Mutable) && !t.symbol.is(Flags.Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
       desugarIdent(t) match {
         case Some(t) => readingOnlyVals(t)
         case None => true
diff --git a/tests/run/byname-param.check b/tests/run/byname-param.check
new file mode 100644
index 000000000000..8750227c71b9
--- /dev/null
+++ b/tests/run/byname-param.check
@@ -0,0 +1,3 @@
+1
+1
+()
diff --git a/tests/run/byname-param.scala b/tests/run/byname-param.scala
new file mode 100644
index 000000000000..cde63db328f2
--- /dev/null
+++ b/tests/run/byname-param.scala
@@ -0,0 +1,12 @@
+object Test {
+
+  // Devalify shouldn't optimize this
+  def theTrap(cond: Boolean, t: => Unit) = {
+    val a,b = t
+    if (cond) println(a) else println(b)
+  }
+
+  def main(args: Array[String]): Unit = {
+    theTrap(true, println(1))
+  }
+}

From 1b6074c12bae7132d48063b52e74bc4ee457e93b Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 20 Sep 2016 11:16:30 +0200
Subject: [PATCH 43/88] Simplify: fix infinite recursion in followCases

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 202d25447015..32e5f5a86276 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -473,9 +473,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
       }
 
-      def followCases(t: Symbol): Symbol = if (t.symbol.is(Flags.Label)) {
+      def followCases(t: Symbol, limit: Int = 0): Symbol = if (t.symbol.is(Flags.Label)) {
         // todo: this can create cycles, see ./tests/pos/rbtree.scala
-        followCases(forwarderWritesTo.getOrElse(t.symbol, NoSymbol))
+        if (limit > 100 && limit > forwarderWritesTo.size + 1) NoSymbol
+          // there may be cycles in labels, that never in the end write to a valdef(the value is always on stack)
+          // there's not much we can do here, except finding such cases and bailing out
+          // there may not be a cycle bigger that hashmapSize > 1
+        else followCases(forwarderWritesTo.getOrElse(t.symbol, NoSymbol), limit + 1)
       } else t
 
       hasPerfectRHS.clear()

From d25a221ca3283ac5609ca93882e4876ee51f6454 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 20 Sep 2016 11:16:54 +0200
Subject: [PATCH 44/88] Simplify: remove duplicate null tests.

---
 .../dotc/transform/linker/Simplify.scala      | 29 +++++++++++++++++--
 1 file changed, 26 insertions(+), 3 deletions(-)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 32e5f5a86276..b1d6ddf86701 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -387,7 +387,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           hasPerfectRHS(symbol) = true
         case Apply(fun, _) if fun.symbol.is(Flags.Label) && (fun.symbol ne symbol) =>
           checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + fun.symbol)
-          assert(forwarderWritesTo.getOrElse(t.symbol, symbol) == symbol)
+          //assert(forwarderWritesTo.getOrElse(t.symbol, symbol) == symbol)
           forwarderWritesTo(t.symbol) = symbol
         case t: Ident if !t.symbol.owner.isClass && (t.symbol ne symbol) =>
           checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + t.symbol)
@@ -536,13 +536,28 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     recur(t)
   }
 
+  private def collectNullTests(t: Tree)(implicit ctx: Context): List[Symbol] = {
+    def recur(t: Tree): List[Symbol] =
+      t match {
+        case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
+        case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
+        case Apply(fun @Select(x, _), List(tp)) if fun.symbol eq defn.Object_ne =>
+          if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
+            x.symbol :: Nil
+          else Nil
+        case _ => List.empty
+      }
+    recur(t)
+  }
+
   val dropGoodCasts: Optimization = { (ctx0: Context) => {
     implicit val ctx: Context = ctx0
 
     val transformer: Transformer = () => localCtx => {
       case t @ If(cond, thenp, elsep) =>
-        val newTested = collectTypeTests(cond)
-        val testedMap = newTested.foldRight[Map[Symbol, List[Type]]](Map.empty)((x, y) =>
+        val newTypeTested = collectTypeTests(cond)
+        val nullTested = collectNullTests(cond).toSet
+        val testedMap = newTypeTested.foldRight[Map[Symbol, List[Type]]](Map.empty)((x, y) =>
           y + ((x._1, x._2 :: y.getOrElse(x._1, Nil)))
         )
         val dropGoodCastsInStats = new TreeMap() {
@@ -555,6 +570,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               })
               if (nstats eq t.stats) t
               else Block(nstats, t.expr)
+            case Apply(fun @ Select(lhs, _), List(Literal(const)))
+              if const.tag == Constants.NullTag && (fun.symbol == defn.Object_eq || fun.symbol == defn.Object_ne) && nullTested.contains(lhs.symbol) =>
+              if (fun.symbol == defn.Object_eq) Literal(Constant(false))
+              else Literal(Constant(true))
+            case Apply(fun @ Select(Literal(const), _), List(rhs))
+              if const.tag == Constants.NullTag && (fun.symbol == defn.Object_eq || fun.symbol == defn.Object_ne) && nullTested.contains(rhs.symbol) =>
+              if (fun.symbol == defn.Object_eq) Literal(Constant(false))
+              else Literal(Constant(true))
             case t => t
           }
         }

From f79f06f05e3a2c0c8ae431a6065f5eff334d165d Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 20 Sep 2016 11:17:17 +0200
Subject: [PATCH 45/88] Simplify: this can be dropped inside a block.

---
 src/dotty/tools/dotc/transform/linker/Simplify.scala | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/src/dotty/tools/dotc/transform/linker/Simplify.scala
index b1d6ddf86701..f7323301c997 100644
--- a/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -592,6 +592,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
     t match {
       case t: Literal => EmptyTree
+      case t: This => EmptyTree
       case Typed(exp, tpe) =>
         keepOnlySideEffects(exp)
       case t @ If(cond, thenp, elsep) =>

From 6cc53c76309284f234e68a686ae4d75a2f2e90cf Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 1 Mar 2017 15:16:24 +0100
Subject: [PATCH 46/88] Finish rebase over dotty upstream

---
 compiler/src/dotty/tools/dotc/Compiler.scala         | 12 ++++++++----
 compiler/src/dotty/tools/dotc/core/StdNames.scala    |  1 +
 .../dotty/tools/dotc/transform/linker/Analysis.scala |  2 +-
 .../linker}/PatternConstantsFactorization.scala      |  1 +
 .../transform/linker}/PatternFactorization.scala     |  4 ++--
 .../transform/linker}/PatternTypeFactorization.scala |  0
 .../dotty/tools/dotc/transform/linker/Simplify.scala |  0
 7 files changed, 13 insertions(+), 7 deletions(-)
 rename {src => compiler/src}/dotty/tools/dotc/transform/linker/Analysis.scala (99%)
 rename {src/dotty/tools/dotc/transform => compiler/src/dotty/tools/dotc/transform/linker}/PatternConstantsFactorization.scala (99%)
 rename {src/dotty/tools/dotc/transform => compiler/src/dotty/tools/dotc/transform/linker}/PatternFactorization.scala (94%)
 rename {src/dotty/tools/dotc/transform => compiler/src/dotty/tools/dotc/transform/linker}/PatternTypeFactorization.scala (100%)
 rename {src => compiler/src}/dotty/tools/dotc/transform/linker/Simplify.scala (100%)

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 8ee016117de3..a943fdb7082f 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/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.
diff --git a/compiler/src/dotty/tools/dotc/core/StdNames.scala b/compiler/src/dotty/tools/dotc/core/StdNames.scala
index 60c6a6ed06c0..79de21759ef8 100644
--- a/compiler/src/dotty/tools/dotc/core/StdNames.scala
+++ b/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"
diff --git a/src/dotty/tools/dotc/transform/linker/Analysis.scala b/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
similarity index 99%
rename from src/dotty/tools/dotc/transform/linker/Analysis.scala
rename to compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
index 64c74f1009ce..6719acd57222 100644
--- a/src/dotty/tools/dotc/transform/linker/Analysis.scala
+++ b/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) =>
diff --git a/src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala b/compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala
similarity index 99%
rename from src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala
rename to compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala
index 20256251c6ce..98afaa48be84 100644
--- a/src/dotty/tools/dotc/transform/PatternConstantsFactorization.scala
+++ b/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)
   }
+
 }
diff --git a/src/dotty/tools/dotc/transform/PatternFactorization.scala b/compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala
similarity index 94%
rename from src/dotty/tools/dotc/transform/PatternFactorization.scala
rename to compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala
index 6cff62ddce04..a7c87774c5fd 100644
--- a/src/dotty/tools/dotc/transform/PatternFactorization.scala
+++ b/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)
diff --git a/src/dotty/tools/dotc/transform/PatternTypeFactorization.scala b/compiler/src/dotty/tools/dotc/transform/linker/PatternTypeFactorization.scala
similarity index 100%
rename from src/dotty/tools/dotc/transform/PatternTypeFactorization.scala
rename to compiler/src/dotty/tools/dotc/transform/linker/PatternTypeFactorization.scala
diff --git a/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
similarity index 100%
rename from src/dotty/tools/dotc/transform/linker/Simplify.scala
rename to compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala

From 232761c1214886605e51f43d0c51496e9085607e Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Thu, 2 Mar 2017 11:03:20 +0100
Subject: [PATCH 47/88] Document Simplify optimizations

@DarkDimius this is what I remember from our conversation yesterday. Could you
check that I got the valify/devalify/varify right? It's mostly a brain dump
from what you explained, I didn't spent too much time trying to reverse
engineer the code.

I also took the liberty to reformat a few things (such as { (ctx0: Context) =>
{ implicit val ctx: Context = ctx0 <body> } }), I hope these are improvement.
---
 .../dotc/transform/linker/Simplify.scala      | 351 +++++++++++-------
 1 file changed, 217 insertions(+), 134 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index f7323301c997..7a99dce5ca65 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -21,7 +21,12 @@ import dotty.tools.dotc.typer.ConstFold
 import scala.collection.mutable
 import scala.collection.mutable.ListBuffer
 
-
+/** This phase consists of a series of small, simple, local optimizations
+ *  applied as a fix point transformation over Dotty Trees.
+ *
+ *  The termination condition uses referential equality on Trees. Furthermore,
+ *  termination relies of every optimization to be shrinking transformations.
+ */
 class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   import tpd._
 
@@ -31,8 +36,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   private var symmetricOperations: Set[Symbol] = null
   var optimize = false
 
-
-
   override def prepareForUnit(tree: _root_.dotty.tools.dotc.ast.tpd.Tree)(implicit ctx: Context): TreeTransform = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
     symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
@@ -100,6 +103,19 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   val NoVisitor: Visitor = (_) => ()
   type Transformer = () => (Context => Tree => Tree)
+
+  /** Every optimization is a function of the following type.
+   *
+   *  - String is the optimization name (for debugging)
+   *
+   *  - ErasureCompatibility is flag indicating whether this optimization can
+   *    be run before or after Erasure (or both).
+   *
+   *  - Visitor is run first to gather information on Trees (using mutation)
+   *
+   *  - Transformer does the actual Tree => Tree transformation, possibly
+   *  - using a different context from the one using in Optimization.
+   */
   type Optimization = (Context) => (String, ErasureCompatibility, Visitor, Transformer)
 
   private lazy val _optimizations: Seq[Optimization] = Seq(
@@ -159,8 +175,18 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     } else tree
   }
 
-  val inlineCaseIntrinsics: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Inline case class specific methods using desugarings assumptions.
+   *
+   * - CC.apply(args)              → new CC(args)
+   * - Seq.unapplySeq(arg)         → new Some(arg)  // where Seq is any companion of type <: SeqFactoryClass
+   *
+   * Dotty only:
+   * - CC.unapply(arg): Boolean    → true
+   *
+   * Scala2 only:
+   * - CC.unapply(arg): Option[CC] → new Some(new scala.TupleN(arg._1, ..., arg._N))
+   */
+  val inlineCaseIntrinsics: Optimization = { implicit ctx: Context =>
     val transformer: Transformer = () => localCtx => {
       case a: Apply if !a.tpe.isInstanceOf[MethodicType] && a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
         (a.symbol.name == nme.apply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
@@ -213,10 +239,18 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t => t
     }
     ("inlineCaseIntrinsics", BeforeAndAfterErasure, NoVisitor, transformer)
-  }}
-  
-  val constantFold: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  }
+
+  /** Various constant folding.
+   *
+   *  - Starts/ends with the constant folding implemented in typer (ConstFold).
+   *
+   *  - (if) specific optimization that propagate booleans, negation, and factor
+   *    out (nested) if with equivalent branches wrt to isSimilar (using &&,||).
+   *
+   *  - Constant propagation over pattern matching.
+   */
+  val constantFold: Optimization = { implicit ctx: Context =>
     def preEval(t: Tree) = {
       if (t.isInstanceOf[Literal] || t.isInstanceOf[CaseDef] || !isPureExpr(t)) t else {
         val s = ConstFold.apply(t)
@@ -281,7 +315,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           cond
         }  else if (!thenp.const.booleanValue && elsep.const.booleanValue) {
           cond.select(defn.Boolean_!).ensureApplied
-        } else ??? //should never happen becase it would be similar
+        } else ??? //should never happen because it would be similar
 //         the lower two are disabled, as it may make the isSimilar rule not apply for a nested structure of iffs.
 //         see the example below:
     //        (b1, b2) match {
@@ -371,10 +405,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         } else t
     }}
     ("constantFold", BeforeAndAfterErasure, NoVisitor, transformer)
-  }}
+  }
 
-  val inlineLocalObjects: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Inline" case classes as vals, this essentially (local) implements multi
+   *  parameter value classes. The main motivation is to get ride of all the
+   *  intermediate tuples coming from pattern matching expressions.
+   */
+  val inlineLocalObjects: Optimization = { implicit ctx: Context =>
     val hasPerfectRHS = collection.mutable.HashMap[Symbol, Boolean]() // in the end only calls constructor. Reason for unconditional inlining
     val checkGood = collection.mutable.HashMap[Symbol, Set[Symbol]]() // if all values have perfect RHS than key has perfect RHS
     val forwarderWritesTo = collection.mutable.HashMap[Symbol, Symbol]()
@@ -520,7 +557,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     res
     }
     ("inlineLocalObjects", BeforeAndAfterErasure, visitor, transformer)
-  }}
+  }
 
   private def collectTypeTests(t: Tree)(implicit ctx: Context): List[(Symbol, Type)] = {
     def recur(t: Tree): List[(Symbol, Type)] =
@@ -550,8 +587,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     recur(t)
   }
 
-  val dropGoodCasts: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Eliminated casts and equality tests whose results can be locally
+   *  determined at compile time:
+   *
+   *  - a.asInstanceOf[T] → a when we know that a: T
+   *  - Simplify (a == null) and (a != null) when the result is statically known
+   */
+  val dropGoodCasts: Optimization = { implicit ctx: Context =>
 
     val transformer: Transformer = () => localCtx => {
       case t @ If(cond, thenp, elsep) =>
@@ -587,88 +629,17 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t => t
     }
     ("dropGoodCasts", BeforeAndAfterErasure, NoVisitor, transformer)
-  }}
-
-  private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
-    t match {
-      case t: Literal => EmptyTree
-      case t: This => EmptyTree
-      case Typed(exp, tpe) =>
-        keepOnlySideEffects(exp)
-      case t @ If(cond, thenp, elsep) =>
-        val nthenp = keepOnlySideEffects(thenp)
-        val nelsep = keepOnlySideEffects(elsep)
-        if (thenp.isEmpty && elsep.isEmpty) keepOnlySideEffects(cond)
-        else cpy.If(t)(
-          thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else  tpd.unitLiteral),
-          elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else  tpd.unitLiteral))
-      case Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
-        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))=>
-        keepOnlySideEffects(rec) // accessing a field of a product
-      case Select(qual, _) if !t.symbol.is(Flags.Mutable | Flags.Lazy) && (!t.symbol.is(Flags.Method) || t.symbol.isGetter) =>
-        keepOnlySideEffects(qual)
-      case Block(List(t: DefDef), s: Closure) => EmptyTree
-      case bl@Block(stats, expr) =>
-        val stats1 = stats.mapConserve(keepOnlySideEffects)
-        val stats2 = if (stats1 ne stats) stats1.filter(x=>x ne EmptyTree) else stats1
-        val expr2: tpd.Tree = expr match {
-          case t: Literal if t.tpe.derivesFrom(defn.UnitClass) => expr
-          case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
-        }
-        cpy.Block(bl)(stats2, expr2)
-      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
-        desugarIdent(t) match {
-          case Some(t) => t
-          case None => EmptyTree
-        }
-      case app: Apply if app.fun.symbol.is(Flags.Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
-        val denot = app.fun.symbol.denot
-        //println(s"replacing ${app.symbol}")
-        if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
-          val newLabelType = app.symbol.info match {
-            case mt: MethodType =>
-              mt.derivedMethodType(mt.paramNames, mt.paramTypes, defn.UnitType)
-            case et: ExprType =>
-              et.derivedExprType(defn.UnitType)
-          }
-          val newD = app.symbol.asSymDenotation.copySymDenotation(info = newLabelType)
-          newD.installAfter(this)
-        }
-
-        ref(app.symbol).appliedToArgs(app.args)
-      case t @ Apply(fun, _) if Analysis.effectsDontEscape(t) =>
-        def getArgsss(a: Tree): List[Tree] = a match {
-          case a: Apply => getArgsss(a.fun) ::: a.args
-          case _ => Nil
-        }
-        def getSel(t: Tree): Tree = {t match {
-          case t: Apply => getSel(t.fun)
-          case t: Select => t.qualifier
-          case t: TypeApply => getSel(t.fun)
-          case _ => t
-        }}
-        val args = getArgsss(t)
-        val rec = getSel(t)
-        val prefix = rec match {
-          case t: New =>
-            args.map(keepOnlySideEffects)
-          case _ =>
-            rec :: args.map(keepOnlySideEffects)
-        }
-        Block(prefix, tpd.unitLiteral)
-      case t @ TypeApply(Select(rec, _), List(testType)) if t.symbol.eq(defn.Any_asInstanceOf) && testType.tpe.widenDealias.typeSymbol.exists =>
-        val receiverType = TypeErasure.erasure(rec.tpe)
-        val erazedTestedType = TypeErasure.erasure(testType.tpe)
-        if (receiverType.derivesFrom(erazedTestedType.typeSymbol))
-          EmptyTree
-        else t
-      case _ => t
-    }
   }
 
-  val removeUnnecessaryNullChecks: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Eliminated null checks based on the following observations:
+   *
+   *  - (this)  cannot be null
+   *  - (new C) cannot be null
+   *  - literal is either null itself or non null
+   *  - fallsback to `tpe.isNotNull`, which will eventually be true for non nullable types.
+   *  - in (a.call; a == null), the first call throws a NPE if a is null; the test can be removed.
+   */
+  val removeUnnecessaryNullChecks: Optimization = { implicit ctx: Context =>
     val initializedVals = mutable.HashSet[Symbol]()
     val checkGood = mutable.HashMap[Symbol, Set[Symbol]]()
     def isGood(t: Symbol) = {
@@ -736,10 +707,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
     ("removeUnnecessaryNullChecks", BeforeAndAfterErasure, visitor,
       transformer)
-  }}
+  }
 
-  val bubbleUpNothing: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Every pure statement preceding a ??? can be removed.
+   *
+   *  This optimization makes it rather tricky meaningful examples since the
+   *  compiler will often be able to reduce them to a single main with ???...
+   */
+  val bubbleUpNothing: Optimization = { implicit ctx: Context =>
     val transformer: Transformer = () => localCtx => {
       case Apply(Select(qual, _), args)  if qual.tpe.derivesFrom(defn.NothingClass) => qual
       case Apply(Select(qual, _), args)  if args.exists(x => x.tpe.derivesFrom(defn.NothingClass)) =>
@@ -755,10 +730,91 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t => t
     }
     ("bubbleUpNothing", BeforeAndAfterErasure, NoVisitor, transformer)
-  }}
+  }
+
+  private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
+    t match {
+      case t: Literal => EmptyTree
+      case t: This => EmptyTree
+      case Typed(exp, tpe) =>
+        keepOnlySideEffects(exp)
+      case t @ If(cond, thenp, elsep) =>
+        val nthenp = keepOnlySideEffects(thenp)
+        val nelsep = keepOnlySideEffects(elsep)
+        if (thenp.isEmpty && elsep.isEmpty) keepOnlySideEffects(cond)
+        else cpy.If(t)(
+          thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else  tpd.unitLiteral),
+          elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else  tpd.unitLiteral))
+      case Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
+        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))=>
+        keepOnlySideEffects(rec) // accessing a field of a product
+      case Select(qual, _) if !t.symbol.is(Flags.Mutable | Flags.Lazy) && (!t.symbol.is(Flags.Method) || t.symbol.isGetter) =>
+        keepOnlySideEffects(qual)
+      case Block(List(t: DefDef), s: Closure) => EmptyTree
+      case bl@Block(stats, expr) =>
+        val stats1 = stats.mapConserve(keepOnlySideEffects)
+        val stats2 = if (stats1 ne stats) stats1.filter(x=>x ne EmptyTree) else stats1
+        val expr2: tpd.Tree = expr match {
+          case t: Literal if t.tpe.derivesFrom(defn.UnitClass) => expr
+          case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
+        }
+        cpy.Block(bl)(stats2, expr2)
+      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
+        desugarIdent(t) match {
+          case Some(t) => t
+          case None => EmptyTree
+        }
+      case app: Apply if app.fun.symbol.is(Flags.Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
+        // This is "the scary hack". It changes the return type to Unit, then
+        // invalidates the denotation cache. Because this optimization only
+        // operates locally, this should be fine.
+        val denot = app.fun.symbol.denot
+        //println(s"replacing ${app.symbol}")
+        if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
+          val newLabelType = app.symbol.info match {
+            case mt: MethodType =>
+              mt.derivedMethodType(mt.paramNames, mt.paramTypes, defn.UnitType)
+            case et: ExprType =>
+              et.derivedExprType(defn.UnitType)
+          }
+          val newD = app.symbol.asSymDenotation.copySymDenotation(info = newLabelType)
+          newD.installAfter(this)
+        }
 
-  val dropNoEffects: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+        ref(app.symbol).appliedToArgs(app.args)
+      case t @ Apply(fun, _) if Analysis.effectsDontEscape(t) =>
+        def getArgsss(a: Tree): List[Tree] = a match {
+          case a: Apply => getArgsss(a.fun) ::: a.args
+          case _ => Nil
+        }
+        def getSel(t: Tree): Tree = {t match {
+          case t: Apply => getSel(t.fun)
+          case t: Select => t.qualifier
+          case t: TypeApply => getSel(t.fun)
+          case _ => t
+        }}
+        val args = getArgsss(t)
+        val rec = getSel(t)
+        val prefix = rec match {
+          case t: New =>
+            args.map(keepOnlySideEffects)
+          case _ =>
+            rec :: args.map(keepOnlySideEffects)
+        }
+        Block(prefix, tpd.unitLiteral)
+      case t @ TypeApply(Select(rec, _), List(testType)) if t.symbol.eq(defn.Any_asInstanceOf) && testType.tpe.widenDealias.typeSymbol.exists =>
+        val receiverType = TypeErasure.erasure(rec.tpe)
+        val erazedTestedType = TypeErasure.erasure(testType.tpe)
+        if (receiverType.derivesFrom(erazedTestedType.typeSymbol))
+          EmptyTree
+        else t
+      case _ => t
+    }
+  }
+
+  /** Removes side effect free statements in blocks. */
+  val dropNoEffects: Optimization = { implicit ctx: Context =>
 
     val transformer: Transformer = () => localCtx => {
       case Block(Nil, expr) => expr
@@ -787,10 +843,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t => t
     }
     ("dropNoEffects", BeforeAndAfterErasure, NoVisitor, transformer)
-  }}
+  }
 
-  val inlineLabelsCalledOnce: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Inlines LabelDef which are used exactly once. */
+  val inlineLabelsCalledOnce: Optimization = { implicit ctx: Context =>
     val timesUsed = collection.mutable.HashMap[Symbol, Int]()
     val defined = collection.mutable.HashMap[Symbol, DefDef]()
 
@@ -827,11 +883,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t => t
     }
     ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
-  }}
+  }
 
-  val jumpjump: Optimization = { (ctx0: Context) => {
+  /** Rewrites pairs of consecutive LabelDef jumps by jumping directly to the target. */
+  val jumpjump: Optimization = { implicit ctx: Context =>
     // optimize label defs that call other label-defs
-    implicit val ctx: Context = ctx0
     val defined = collection.mutable.HashMap[Symbol, Symbol]()
 
     val visitor: Visitor = {
@@ -859,10 +915,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t => t
     }
     ("jumpjump", BeforeAndAfterErasure, visitor, transformer)
-  }}
+  }
 
-  val inlineOptions: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Inlines Option methods whose result is known statically. */
+  val inlineOptions: Optimization = { implicit ctx: Context =>
     val somes = collection.mutable.HashMap[Symbol, Tree]()
     val nones = collection.mutable.HashSet[Symbol]()
 
@@ -910,11 +966,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       else tree
     }
     ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
-  }}
+  }
 
-  val valify: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
-     // either a duplicate or a read through series of immutable fields
+  /** Rewrite vars with exactly one assignment as vals. */
+  val valify: Optimization = { implicit ctx: Context =>
+    // either a duplicate or a read through series of immutable fields
     val defined: mutable.Map[Symbol, ValDef] = mutable.Map()
     val firstRead: mutable.Map[Symbol, RefTree] = mutable.Map()
     val firstWrite: mutable.Map[Symbol, Assign] = mutable.Map()
@@ -943,23 +999,24 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val transformer: Transformer = () => localCtx => {
       val transformation: Tree => Tree = {
         case t: Block => // drop non-side-effecting stats
-          val valdefs = t.stats.filter(x => x match  {
+          val valdefs = t.stats.filter {
             case t: ValDef if defined.contains(t.symbol) => true
             case _ => false
-          }).asInstanceOf[List[ValDef]]
-          val assigns = t.stats.filter(x => x match {
+          }.asInstanceOf[List[ValDef]]
+
+          val assigns = t.stats.filter {
             case t @ Assign(lhs, r) =>
               firstWrite.contains(lhs.symbol) && !secondWrite.contains(lhs.symbol)
             case _ => false
-          })
+          }
 
           val pairs = valdefs.flatMap(x => assigns.find(y => y.asInstanceOf[Assign].lhs.symbol == x.symbol) match {
             case Some(y: Assign) => List((x, y))
             case _ => Nil
           })
 
-          val valsToDrop = pairs.map(x => x._1).toSet
-          val assignsToReplace: Map[Assign, ValDef] = pairs.map(x => (x._2, x._1)).toMap
+          val valsToDrop = pairs.map(_._1).toSet
+          val assignsToReplace: Map[Assign, ValDef] = pairs.map(_.swap).toMap
 
           val newStats = t.stats.mapConserve {
             case x: ValDef if valsToDrop.contains(x) => EmptyTree
@@ -981,10 +1038,22 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       transformation
     }
     ("valify", BeforeAndAfterErasure, visitor, transformer)
-  }}
+  }
 
-  val devalify: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Gets ride of duplicate parameters of tail recursive functions using mutable parameter.
+   *
+   *  Unlike what's done in scalac, this is limited to the simple cases,
+   *  for instance, we would not optimize anything in the following case:
+   *
+   *  def f(x, y) = f(x + y + 1, x - y - 1)
+   *
+   *  In scalac the above is optimized using a by code trick which cannot be
+   *  expressed in bytecode. In the example above, x can be turned into a var
+   *  by first doing a DUP to push the current value onto the stack. This
+   *  introduces a tight coupling between backend and tqilreq which we prefer
+   *  to avoid in dotty.
+   */
+  val devalify: Optimization = { implicit ctx: Context =>
     val timesUsed = collection.mutable.HashMap[Symbol, Int]()
     val defined = collection.mutable.HashSet[Symbol]()
     val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
@@ -1002,7 +1071,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val b4 = timesUsed.getOrElseUpdate(symIfExists, 0)
         timesUsed.put(symIfExists, b4 + 1)
 
-      case valdef: ValDef  if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
+      case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
         //todo: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 
@@ -1013,7 +1082,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
 
     val transformer: Transformer = () => localCtx => {
-
       val valsToDrop = defined -- timesUsed.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
         val rhs = dropCasts(x._2)
@@ -1028,7 +1096,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             case None => Nil
           })
 
-
       val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce
 
       val deepReplacer = new TreeMap() {
@@ -1073,10 +1140,24 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       transformation
     }
     ("devalify", BeforeAndAfterErasure, visitor, transformer)
-  }}
+  }
 
-  val varify: Optimization = { (ctx0: Context) => {
-    implicit val ctx: Context = ctx0
+  /** Inline val with exactly one assignment to a var. For example:
+   *
+   *  {
+   *    val l = <expr>
+   *    var r = l
+   *    // code not using l
+   *  }
+   *
+   *  becomes:
+   *
+   *  {
+   *    var r = <expr>
+   *    // code not using l
+   *  }
+   */
+  val varify: Optimization = { implicit ctx: Context =>
     val paramsTimesUsed = collection.mutable.HashMap[Symbol, Int]()
     val possibleRenames = collection.mutable.HashMap[Symbol, Set[Symbol]]()
     val visitor: Visitor = {
@@ -1101,8 +1182,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
     val transformer: Transformer = () => localCtx => {
       val paramCandidates = paramsTimesUsed.filter(kv => kv._2 == 1).keySet
-      val renames = possibleRenames.iterator.map(kv => (kv._1, kv._2.intersect(paramCandidates))).
-        filter(x => x._2.nonEmpty).map(x => (x._1, x._2.head)).toMap
+      val renames: Map[Symbol, Symbol] = possibleRenames.iterator
+        .map(kv => (kv._1, kv._2.intersect(paramCandidates)))
+        .filter(x => x._2.nonEmpty)
+        .map(x => (x._1, x._2.head))
+        .toMap
       val transformation: Tree => Tree = {
         case t: RefTree
           if renames.contains(t.symbol) =>
@@ -1121,8 +1205,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       transformation
     }
     ("varify", AfterErasure, visitor, transformer)
-  }}
-
+  }
 
   private def unzip4[A, B, C, D](seq: Seq[(A, B, C, D)]): (Seq[A], Seq[B], Seq[C], Seq[D]) = {
     val listBuilderA = new ListBuffer[A]()

From 76af6c53cd65a8569069b5fed00aa9ca12e30ee7 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Tue, 11 Apr 2017 15:06:32 +0200
Subject: [PATCH 48/88] Fix Erasure of uniqueRefDenotations with different
 underlying type.

The bug happened for `new Tuple2[Int, Int](1, 2)._1`, if the last
`._1` selection is done by symbol. This will create a
uniqueRefDenotation with underlying type Int.

This denotation has to be erased in conformance with underlying type,
not with the observed type before erasure, as otherwise you'd think
that `_1` on topple returns Int.
---
 compiler/src/dotty/tools/dotc/core/TypeErasure.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index d2aefc68483b..e3f4205494c8 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -440,7 +440,7 @@ class TypeErasure(isJava: Boolean, semiEraseVCs: Boolean, isConstructor: Boolean
         // but potentially re-introduced by ResolveSuper, when we add
         // forwarders to mixin methods.
         // See doc comment for ElimByName for speculation how we could improve this.
-      else MethodType(Nil, Nil, eraseResult(rt))
+      else MethodType(Nil, Nil, eraseResult(sym.info.finalResultType))
     case tp: PolyType =>
       eraseResult(tp.resultType) match {
         case rt: MethodType => rt

From aaca2b157094bba56834793c97fd59f89fdcd2f8 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Wed, 26 Apr 2017 17:23:37 +0200
Subject: [PATCH 49/88] Rewrite labelDefs phase

This one has no checking and does not assume anything about how labels
work. But if labels are generated wrong, it does not try to fix it or
warn about it.

In case labels are wrong - now you'll get a crash in backend.

--

Manually cherry picked from https://github.com/dotty-linker/dotty/commit/11e780856acaf3701c5f8b92ab93a340b39525d3
---
 .../dotty/tools/backend/jvm/LabelDefs.scala   | 97 ++-----------------
 1 file changed, 9 insertions(+), 88 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
index d4f09e99159a..8ea9638519a7 100644
--- a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
+++ b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
@@ -90,76 +90,24 @@ class LabelDefs extends MiniPhaseTransform {
     else {
       collectLabelDefs.clear
       val newRhs = collectLabelDefs.transform(tree.rhs)
-      val labelCalls = collectLabelDefs.labelCalls
-      var entryPoints = collectLabelDefs.parentLabelCalls
       var labelDefs = collectLabelDefs.labelDefs
-      var callCounts = collectLabelDefs.callCounts
-
-      // make sure that for every label there's a single location it should return and single entry point
-      // if theres already a location that it returns to that's a failure
-      val disallowed = new mutable.HashMap[Symbol, Tree]()
-      queue.sizeHint(labelCalls.size + entryPoints.size)
 
       def putLabelDefsNearCallees = new TreeMap() {
 
         override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
           tree match {
-            case t: Apply if (entryPoints.contains(t)) =>
-              entryPoints = entryPoints - t
-              labelLevel = labelLevel + 1
-              val r = Block(moveLabels(t), t)
-              labelLevel = labelLevel - 1
-              if (labelLevel == 0) beingAppended.clear()
-              r
-            case _ => if (entryPoints.nonEmpty && labelDefs.nonEmpty) super.transform(tree) else tree
-          }
-
-        }
-      }
-
-      def moveLabels(entryPoint: Apply): List[Tree] = {
-        val entrySym = entryPoint.symbol
-        if ((entrySym is Flags.Label) && labelDefs.contains(entrySym)) {
-          val visitedNow = new mutable.HashMap[Symbol, Tree]()
-          val treesToAppend = new ArrayBuffer[Tree]() // order matters. parents should go first
-          treesToAppend += labelDefs(entrySym)
-          queue.clear()
+            case t: Apply if labelDefs.contains(t.symbol) =>
+              val labelDef = labelDefs(t.symbol)
+              labelDefs -= t.symbol
 
-          var visited = 0
-          queue += entryPoint
-          while (visited < queue.size) {
-            val owningLabelDefSym = queue(visited).symbol
-            for (call <- labelCalls(owningLabelDefSym)) {
-              val callSym = call.symbol
-              if (!beingAppended.contains(callSym)) {
-                if (disallowed.contains(callSym)) {
-                  val oldCall = disallowed(callSym)
-                  ctx.error(s"Multiple return locations for Label $oldCall and $call", callSym.pos)
-                } else {
-                  if ((!visitedNow.contains(callSym)) && labelDefs.contains(callSym)) {
-                    val defTree = labelDefs(callSym)
-                    visitedNow.put(callSym, defTree)
-                    val callCount = callCounts(callSym)
-                    if (callCount > 1) {
-                      if (!treesToAppend.contains(defTree)) {
-                        treesToAppend += defTree
-                        queue += call
+              val labelDef2 = transform(labelDef)
+              Block(labelDef2:: Nil, t)
 
-                      }
-                    } else if (entryPoint.symbol ne callSym) entryPoints += call
-                  }
-                }
-              }
-            }
-
-            visited += 1
+            case _ => if (labelDefs.nonEmpty) super.transform(tree) else tree
           }
-          beingAppended ++= treesToAppend.map(_.symbol)
-          treesToAppend.toList.map(putLabelDefsNearCallees.transform)
-        } else Nil
+        }
       }
 
-
       val res = cpy.DefDef(tree)(rhs = putLabelDefsNearCallees.transform(newRhs))
 
       res
@@ -168,22 +116,11 @@ class LabelDefs extends MiniPhaseTransform {
 
   object collectLabelDefs extends TreeMap() {
 
-    // label calls from this DefDef
-    var parentLabelCalls: mutable.Set[Tree] = new mutable.HashSet[Tree]()
-    var callCounts: mutable.Map[Symbol, Int] = new mutable.HashMap[Symbol, Int]().withDefaultValue(0)
-
-    def shouldMoveLabel = true
-
     // labelSymbol -> Defining tree
     val labelDefs = new mutable.HashMap[Symbol, Tree]()
-    // owner -> all calls by this owner
-    val labelCalls = new mutable.HashMap[Symbol, mutable.Set[Tree]]()
-    var owner: Symbol = null
 
     def clear = {
-      parentLabelCalls.clear()
       labelDefs.clear()
-      labelCalls.clear()
     }
 
     override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = tree match {
@@ -196,30 +133,14 @@ class LabelDefs extends MiniPhaseTransform {
         }
       case t: DefDef =>
         assert(t.symbol is Flags.Label)
-
-        val st = parentLabelCalls
-        parentLabelCalls = new mutable.HashSet[Tree]()
-        val symt = owner
-        owner = t.symbol
-
         val r = super.transform(tree)
-
-        owner = symt
-        labelCalls(r.symbol) = parentLabelCalls
-        parentLabelCalls = st
-
-        if (shouldMoveLabel) {
-          labelDefs(r.symbol) = r
-          EmptyTree
-        } else r
+        labelDefs(r.symbol) = r
+        EmptyTree
       case t: Apply if t.symbol is Flags.Label =>
         val sym = t.symbol
-        parentLabelCalls = parentLabelCalls + t
-        if (owner != sym) callCounts(sym) = callCounts(sym) + 1
         super.transform(tree)
       case _ =>
         super.transform(tree)
-
     }
   }
 }

From b7596efc357cff112c59242647e34f3ebba06d47 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Thu, 27 Apr 2017 14:22:04 +0200
Subject: [PATCH 50/88] Soften Ycheck scoping rules for local jumps after
 LabelDefs

LabelDefs phase now may move labels into other labels if this is
the right location to emmig the go-to. This may break scoping rules.

Possible solution was to disable Ycheck, but as there are other tricky
phases now in the same phase block, I preferred to teach Ycheck to lift
more restrictions on LabelDefs.
Ycheck already knew something about LabelDefs, as it used to break
ownership links for go-tos, but not it also breaks scoping rules.

Demonstrated by tests/run/t1333.scala

Thanks @OlivierBlanvillain for nice minimization.
---
 compiler/src/dotty/tools/backend/jvm/LabelDefs.scala      | 7 +++++--
 compiler/src/dotty/tools/dotc/transform/TreeChecker.scala | 5 ++++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
index 8ea9638519a7..eabe1d3b0c3b 100644
--- a/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
+++ b/compiler/src/dotty/tools/backend/jvm/LabelDefs.scala
@@ -75,8 +75,11 @@ import StdNames.nme
  * Unreachable jumps will be eliminated by local dead code analysis.
  * After JVM is smart enough to remove next-line jumps
  *
- * Note that Label DefDefs can be only nested in Block, otherwise no one would
- * be able to call them Other DefDefs are eliminated
+ * Note that his phase Ychecking this phase required softening scoping rules
+ * as it intentionally allowed to break scoping rules inside methods for labels.
+ * This is modified by setting `labelsReordered` flag in Phases.
+ *
+ * @author Dmitry Petrashko
  */
 class LabelDefs extends MiniPhaseTransform {
   def phaseName: String = "labelDef"
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
index 2205a104ef9c..274f114ad9a6 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeChecker.scala
@@ -184,7 +184,10 @@ class TreeChecker extends Phase with SymTransformer {
       vparamss.foldRightBN(op)(withDefinedSyms(_)(_))
 
     def assertDefined(tree: untpd.Tree)(implicit ctx: Context) =
-      if (tree.symbol.maybeOwner.isTerm)
+      if (
+        tree.symbol.maybeOwner.isTerm &&
+        !(tree.symbol.is(Label) && !tree.symbol.owner.isClass && ctx.phase.labelsReordered) // labeldefs breaks scoping
+      )
         assert(nowDefinedSyms contains tree.symbol, i"undefined symbol ${tree.symbol}")
 
     /** assert Java classes are not used as objects */

From a5b688d60ae8f3530216849a08a3c7693949e431 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 15:12:21 +0200
Subject: [PATCH 51/88] Fix compilation after rebase

---
 compiler/src/dotty/tools/dotc/core/NameKinds.scala   |  5 ++++-
 .../dotty/tools/dotc/transform/linker/Simplify.scala | 12 ++++++------
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/NameKinds.scala b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
index d51a1d8cbfef..543b15fb1460 100644
--- a/compiler/src/dotty/tools/dotc/core/NameKinds.scala
+++ b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
@@ -308,6 +308,9 @@ object NameKinds {
   val PatMatCaseName          = new UniqueNameKind("case")
   val PatMatMatchFailName     = new UniqueNameKind("matchFail")
   val PatMatSelectorName      = new UniqueNameKind("selector")
+  val LocalOptFact            = new UniqueNameKind("fact")
+  val LocalOptSelector        = new UniqueNameKind("selector")
+  val LocalOptFallback        = new UniqueNameKind("fallback")
 
   /** The kind of names of default argument getters */
   val DefaultGetterName = new NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
@@ -384,4 +387,4 @@ object NameKinds {
   def qualifiedNameKindOfTag   : collection.Map[Int, QualifiedNameKind]  = qualifiedNameKinds
   def numberedNameKindOfTag    : collection.Map[Int, NumberedNameKind]   = numberedNameKinds
   def uniqueNameKindOfSeparator: collection.Map[String, UniqueNameKind]  = uniqueNameKinds
-}
\ No newline at end of file
+}
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 7a99dce5ca65..5497b521da80 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -66,16 +66,16 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       readingOnlyVals(rec)
     case Apply(Select(rec, _), Nil) =>
       if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
-      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName)
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName)
         readingOnlyVals(rec) // accessing a field of a product
       else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
         readingOnlyVals(rec)
       else false
     case Select(rec, _) if t.symbol.is(Flags.Method) =>
       if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
-      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) {
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) {
         def isImmutableField = {
-          val fieldId = t.symbol.name.drop(1).toString.toInt - 1
+          val fieldId = t.symbol.name.toString.drop(1).toInt - 1
           !t.symbol.owner.caseAccessors(ctx)(fieldId).is(Flags.Mutable)
         }
         if (isImmutableField) readingOnlyVals(rec) // accessing a field of a product
@@ -437,7 +437,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
         checkGood.put(lhs.symbol, checkGood.getOrElse(lhs.symbol, Set.empty) + rhs.symbol)
       case t @ Select(qual, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-        (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.maybeOwner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+        (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.maybeOwner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
         (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
         gettersCalled(qual.symbol) = true
       case t: DefDef if t.symbol.is(Flags.Label) =>
@@ -545,7 +545,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               Thicket(ass :: updates)
           }
         case sel @ Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-          (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
+          (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
           (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
           newMappings.getOrElse(rec.symbol, Map.empty).get(sel.symbol) match {
             case None => t
@@ -774,7 +774,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
           val newLabelType = app.symbol.info match {
             case mt: MethodType =>
-              mt.derivedMethodType(mt.paramNames, mt.paramTypes, defn.UnitType)
+              mt.derivedLambdaType(mt.paramNames, mt.paramInfos, defn.UnitType)
             case et: ExprType =>
               et.derivedExprType(defn.UnitType)
           }

From 4ea9a84ecd29e9952139f0035b015d4a175fe32a Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 13:28:50 +0200
Subject: [PATCH 52/88] Restore tests moved to disabled

---
 tests/{disabled => pos}/GenericTraversableTemplate.scala | 0
 tests/{disabled => pos}/t7126.scala                      | 0
 tests/run/byname-param.scala                             | 1 -
 tests/{disabled => run}/i1144/AB_1.scala                 | 0
 tests/{disabled => run}/i1144/C_2.scala                  | 0
 tests/{disabled => run}/redundantParents.scala           | 0
 tests/{disabled => run}/statics.scala                    | 0
 7 files changed, 1 deletion(-)
 rename tests/{disabled => pos}/GenericTraversableTemplate.scala (100%)
 rename tests/{disabled => pos}/t7126.scala (100%)
 rename tests/{disabled => run}/i1144/AB_1.scala (100%)
 rename tests/{disabled => run}/i1144/C_2.scala (100%)
 rename tests/{disabled => run}/redundantParents.scala (100%)
 rename tests/{disabled => run}/statics.scala (100%)

diff --git a/tests/disabled/GenericTraversableTemplate.scala b/tests/pos/GenericTraversableTemplate.scala
similarity index 100%
rename from tests/disabled/GenericTraversableTemplate.scala
rename to tests/pos/GenericTraversableTemplate.scala
diff --git a/tests/disabled/t7126.scala b/tests/pos/t7126.scala
similarity index 100%
rename from tests/disabled/t7126.scala
rename to tests/pos/t7126.scala
diff --git a/tests/run/byname-param.scala b/tests/run/byname-param.scala
index cde63db328f2..9240604eb95d 100644
--- a/tests/run/byname-param.scala
+++ b/tests/run/byname-param.scala
@@ -1,5 +1,4 @@
 object Test {
-
   // Devalify shouldn't optimize this
   def theTrap(cond: Boolean, t: => Unit) = {
     val a,b = t
diff --git a/tests/disabled/i1144/AB_1.scala b/tests/run/i1144/AB_1.scala
similarity index 100%
rename from tests/disabled/i1144/AB_1.scala
rename to tests/run/i1144/AB_1.scala
diff --git a/tests/disabled/i1144/C_2.scala b/tests/run/i1144/C_2.scala
similarity index 100%
rename from tests/disabled/i1144/C_2.scala
rename to tests/run/i1144/C_2.scala
diff --git a/tests/disabled/redundantParents.scala b/tests/run/redundantParents.scala
similarity index 100%
rename from tests/disabled/redundantParents.scala
rename to tests/run/redundantParents.scala
diff --git a/tests/disabled/statics.scala b/tests/run/statics.scala
similarity index 100%
rename from tests/disabled/statics.scala
rename to tests/run/statics.scala

From 8f470f0eecf89c22a1289ab064f133c7e877fc12 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 13:29:54 +0200
Subject: [PATCH 53/88] Remove PatternConstantsFactorization &
 PatternTypeFactorization for now

---
 compiler/src/dotty/tools/dotc/Compiler.scala  |  10 +-
 .../PatternConstantsFactorization.scala       | 114 ------------------
 .../linker/PatternFactorization.scala         |  99 ---------------
 .../linker/PatternTypeFactorization.scala     |  81 -------------
 tests/disabled/patternFactorization.scala     | 107 ----------------
 5 files changed, 4 insertions(+), 407 deletions(-)
 delete mode 100644 compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala
 delete mode 100644 compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala
 delete mode 100644 compiler/src/dotty/tools/dotc/transform/linker/PatternTypeFactorization.scala
 delete mode 100644 tests/disabled/patternFactorization.scala

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index a943fdb7082f..11b94c9e0264 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -7,15 +7,16 @@ import Periods._
 import Symbols._
 import Types._
 import Scopes._
-import typer.{FrontEnd, ImportInfo, RefChecks, Typer}
-import reporting.{ConsoleReporter, Reporter}
+import typer.{FrontEnd, Typer, ImportInfo, RefChecks}
+import reporting.{Reporter, ConsoleReporter}
 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.{CollectSuperCalls, GenBCode, LabelDefs}
+
+import dotty.tools.backend.jvm.{LabelDefs, GenBCode, CollectSuperCalls}
 import dotty.tools.dotc.transform.linker.Simplify
 
 /** The central class of the dotc compiler. The job of a compiler is to create
@@ -60,9 +61,6 @@ 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
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala b/compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala
deleted file mode 100644
index 98afaa48be84..000000000000
--- a/compiler/src/dotty/tools/dotc/transform/linker/PatternConstantsFactorization.scala
+++ /dev/null
@@ -1,114 +0,0 @@
-package dotty.tools.dotc
-package transform
-
-import TreeTransforms._
-import core.Contexts._
-import core.Constants._
-import dotty.tools.dotc.ast.tpd
-import ast.Trees._
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.ast.Trees._
-import TreeTransforms._
-
-class PatternConstantsFactorization extends PatternFactorization {
-  import dotty.tools.dotc.ast.tpd._
-
-  def phaseName: String = "patternConstantsFactorization"
-
-  //override def runsAfter = Set(classOf[PatternTypeFactorization])
-
-  override def transformTry(tree: Try)(implicit ctx: Context, info: TransformerInfo): Tree = tree
-
-  protected def shouldSwap(caseDef1: CaseDef, caseDef2: CaseDef)(implicit ctx: Context): Boolean = {
-    (caseDef1.pat, caseDef2.pat) match {
-      case (Literal(const1), Literal(const2)) =>
-        if (const1 == const2) false
-        else const1.stringValue > const2.stringValue
-      case _ => false
-    }
-  }
-
-  protected def isOnConstant(caseDef: CaseDef): Boolean = caseDef match {
-    case CaseDef(Literal(Constant(_)), _, _) => true
-    case _                                   => false
-  }
-
-  protected def factorized(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): (List[List[CaseDef]], List[CaseDef]) = {
-    val reordered = reorderedCases(cases)
-    val preFactored = factorCases(reordered)
-    val (factoredConstants, fallbacks) =
-      preFactored.span(cases => isOnConstant(cases.head))
-    if (factoredConstants.nonEmpty) {
-      (factoredConstants, fallbacks.flatten)
-    } else {
-      val (fact, fallbacks1) = fallbacks.span(cases => !isOnConstant(cases.head))
-      if (fallbacks1.nonEmpty) (fact, fallbacks1.flatten)
-      else (Nil, fallbacks.flatten)
-    }
-  }
-
-  protected def asInnerMatchIfNeeded(sel: Symbol, caseDefs: List[CaseDef], fallbackOpt: Option[Tree])(implicit ctx: Context, info: TransformerInfo): CaseDef = {
-    assert(caseDefs.nonEmpty)
-    caseDefs.head match {
-      case caseDef @ CaseDef(Literal(_), EmptyTree, _) if caseDefs.size == 1 => caseDef
-      case CaseDef(lit @ Literal(_), _, _) =>
-        val fallbackCase = fallbackOpt.map(CaseDef(lit, EmptyTree, _))
-        asInnerMatchOnConstant(lit, caseDefs ++ fallbackCase)
-      case caseDef =>
-        val fallbackCase = fallbackOpt.map(CaseDef(Underscore(caseDef.pat.tpe.widen), EmptyTree, _))
-        asInnerMatch(caseDefs ++ fallbackCase)
-    }
-  }
-
-  protected def factorCases(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): List[List[CaseDef]] = {
-    def loop(remaining: List[CaseDef], groups: List[List[CaseDef]]): List[List[CaseDef]] = {
-      remaining match {
-        case CaseDef(lit @ Literal(_), _, _) :: _ =>
-          val (span, rest) = remaining.span {
-            case CaseDef(Literal(Constant(value)), _, _) => value == lit.const.value
-            case _ => false
-          }
-          loop(rest, span :: groups)
-
-        case _ :: _ =>
-          val (span, rest) = remaining.span {
-            case CaseDef(Literal(_), _, _) => false
-            case _ => true
-          }
-          loop(rest, span :: groups)
-
-        case Nil => groups.reverse
-      }
-    }
-    loop(cases, Nil)
-  }
-
-  protected def asInnerMatchOnConstant(lit: Literal, cases: List[CaseDef])(
-      implicit ctx: Context, info: TransformerInfo): CaseDef = {
-    val innerMatch = transformFollowing(Match(lit, cases))
-    CaseDef(lit, EmptyTree, innerMatch)
-  }
-
-  protected def asInnerMatch(cases: List[CaseDef])(
-    implicit ctx: Context, info: TransformerInfo): CaseDef = {
-    assert(cases.nonEmpty)
-    val tpe = cases.head.pat.tpe.widen
-    val selName = ctx.freshName("fact").toTermName
-    val factorizedSelector =
-      ctx.newSymbol(ctx.owner, selName, Flags.Synthetic | Flags.Case, tpe)
-    val selector = Ident(factorizedSelector.termRef)
-    val pattern = Bind(factorizedSelector, Underscore(factorizedSelector.info))
-    val innerMatch = transformFollowing(Match(selector, cases))
-    CaseDef(pattern, EmptyTree, innerMatch)
-  }
-
-}
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala b/compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala
deleted file mode 100644
index a7c87774c5fd..000000000000
--- a/compiler/src/dotty/tools/dotc/transform/linker/PatternFactorization.scala
+++ /dev/null
@@ -1,99 +0,0 @@
-package dotty.tools.dotc.transform
-
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.ast.Trees._
-import TreeTransforms._
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Contexts._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.core.Types._
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags
-import dotty.tools.dotc.core.Constants._
-import dotty.tools.dotc.core.Symbols._
-import dotty.tools.dotc.ast.Trees._
-import TreeTransforms._
-
-trait PatternFactorization extends MiniPhaseTransform {
-  import dotty.tools.dotc.ast.tpd._
-
-  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
-
-  protected def hasCaseWithoutGuard(cases: List[CaseDef]): Boolean = {
-    cases.exists {
-      case CaseDef(_, EmptyTree, _) => true
-      case _                        => false
-    }
-  }
-
-  override def transformMatch(tree: Match)(implicit ctx: Context, info: TransformerInfo): Tree = {
-    //println(s">>> ${this.getClass.getName}.transformMatch  " + tree.selector.tpe.show + " " + tree.tpe.show)
-    //println(tree.show)
-    //tree.cases.foreach(println)
-    //println()
-    val (factoredCases, fallbackCases) = factorized(tree.cases)
-    if (factoredCases.nonEmpty) {
-      val selectorSym =
-        ctx.newSymbol(ctx.owner, ctx.freshName("selector").toTermName, Flags.Synthetic, tree.selector.tpe)
-      val selectorVal = ValDef(selectorSym, tree.selector)
-      val selector = Ident(selectorSym.termRef)
-
-      val fallbackDefDefOpt = {
-        if (fallbackCases.nonEmpty) {
-          val fallbackMatch = transformMatch(Match(selector, fallbackCases))
-          val fallbackName = ctx.freshName("fallback").toTermName
-          val fallbackSym =
-            ctx.newSymbol(ctx.owner, fallbackName, Flags.Synthetic | Flags.Label, MethodType(Nil, Nil)(x => fallbackMatch.tpe))
-          Some(DefDef(fallbackSym, fallbackMatch))
-        } else {
-          None
-        }
-      }
-      val fallbackOpt = fallbackDefDefOpt.map { fallbackDefDef =>
-        Apply(Ident(fallbackDefDef.symbol.termRef), Nil)
-      }
-
-      val newFactoredCases = factoredCases.map(asInnerMatchIfNeeded(selectorSym, _, fallbackOpt))
-
-      val fallbackCaseOpt = fallbackOpt.map { fallback =>
-        CaseDef(Underscore(fallback.symbol.info), EmptyTree, fallback)
-      }
-
-      Block(
-          List(selectorVal) ++ fallbackDefDefOpt,
-          transformFollowing(cpy.Match(tree)(selector, newFactoredCases ++ fallbackCaseOpt))
-      )
-    } else {
-      transformFollowing(tree)
-    }
-  }
-
-  protected def reorderedCases(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): List[CaseDef] = {
-    val casesArray = cases.toArray
-    var swapped = false
-    do {
-      swapped = false
-      for (i <- 1 until casesArray.length) {
-        val tmp1 = casesArray(i - 1)
-        val tmp2 = casesArray(i)
-        if (shouldSwap(tmp1, tmp2)) {
-          swapped = true
-          casesArray(i - 1) = tmp2
-          casesArray(i) = tmp1
-        }
-      }
-    } while (swapped)
-
-    casesArray.toList
-  }
-}
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/PatternTypeFactorization.scala b/compiler/src/dotty/tools/dotc/transform/linker/PatternTypeFactorization.scala
deleted file mode 100644
index a084a45e9de0..000000000000
--- a/compiler/src/dotty/tools/dotc/transform/linker/PatternTypeFactorization.scala
+++ /dev/null
@@ -1,81 +0,0 @@
-package dotty.tools.dotc
-package transform
-
-import TreeTransforms._
-import core.Contexts._
-import core.Symbols._
-import core.Types._
-import dotty.tools.dotc.core.DenotTransformers.DenotTransformer
-import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.core.{Flags, TypeApplications}
-import dotty.tools.dotc.typer.Applications
-import dotty.tools.dotc.util.Positions
-import typer.ErrorReporting._
-import ast.Trees._
-import Applications._
-import TypeApplications._
-import SymUtils._
-import core.NameOps._
-import core.Mode
-import dotty.tools.dotc.util.Positions.Position
-import dotty.tools.dotc.core.Decorators._
-import dotty.tools.dotc.core.Flags
-
-class PatternTypeFactorization extends PatternFactorization {
-  import dotty.tools.dotc.ast.tpd._
-
-  def phaseName: String = "patternTypeFactorization"
-
-  override def runsAfter = Set(classOf[TryCatchPatterns])
-
-  protected def shouldSwap(caseDef1: CaseDef, caseDef2: CaseDef)(implicit ctx: Context): Boolean = false && {
-    // fixme: this is wrong in case of primitives at least. run/matchbytes.scala demostrates this
-    val tpe1 = caseDef1.pat.tpe.widen
-    val tpe2 = caseDef2.pat.tpe.widen
-    tpe1.exists && tpe2.exists && !(tpe1 <:< tpe2) && !(tpe2 <:< tpe1) && tpe1.uniqId < tpe2.uniqId
-  }
-
-  protected def factorized(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): (List[List[CaseDef]], List[CaseDef]) = {
-    val reordered = reorderedCases(cases)
-    val preFactored = factorCases(reordered)
-    val (factoredTypes, fallbacks) = preFactored.span(hasCaseWithoutGuard)
-    if (fallbacks.nonEmpty) {
-      (factoredTypes :+ fallbacks.head, fallbacks.tail.flatten)
-    } else {
-      (factoredTypes, Nil)
-    }
-  }
-
-  protected def asInnerMatchIfNeeded(sel: Symbol, caseDefs: List[CaseDef], fallbackOpt: Option[Tree])(implicit ctx: Context, info: TransformerInfo): CaseDef = {
-    assert(caseDefs.nonEmpty)
-    val fallbackCase = fallbackOpt.map(CaseDef(Underscore(caseDefs.head.pat.tpe.widen), EmptyTree, _))
-    asInnerMatch(sel, caseDefs ++ fallbackCase)
-  }
-
-  protected def factorCases(cases: List[CaseDef])(implicit ctx: Context, info: TransformerInfo): List[List[CaseDef]] = {
-    def loop(remaining: List[CaseDef], groups: List[List[CaseDef]]): List[List[CaseDef]] = {
-      remaining match {
-        case c0 :: tail =>
-          val tpe = c0.pat.tpe.widen
-          val (span, rest) = tail.span(_.pat.tpe <:< tpe)
-          loop(rest, (c0 :: span) :: groups)
-
-        case Nil => groups.reverse
-      }
-    }
-    loop(cases, Nil)
-  }
-
-  protected def asInnerMatch(sel: Symbol, cases: List[CaseDef])(
-    implicit ctx: Context, info: TransformerInfo): CaseDef = {
-    assert(cases.nonEmpty)
-    val tpe = cases.head.pat.tpe.widen.orElse(sel.info.widen)
-    val selName = ctx.freshName("fact").toTermName
-    val factorizedSelector =
-      ctx.newSymbol(ctx.owner, selName, Flags.Synthetic | Flags.Case, tpe)
-    val selector = Ident(factorizedSelector.termRef)
-    val pattern = Bind(factorizedSelector, Typed(Underscore(factorizedSelector.info), TypeTree(factorizedSelector.info)))
-    val innerMatch = transformFollowing(Match(selector, cases))
-    CaseDef(pattern, EmptyTree, innerMatch)
-  }
-}
diff --git a/tests/disabled/patternFactorization.scala b/tests/disabled/patternFactorization.scala
deleted file mode 100644
index f92b20a5d1fd..000000000000
--- a/tests/disabled/patternFactorization.scala
+++ /dev/null
@@ -1,107 +0,0 @@
-
-object Test {
-  def main(args: Array[String]): Unit = {
-    val guard = true
-    (1) match {
-//      case 0 => println("0")
-//      case 1 => println("1")
-//      case 2 if guard => println("2")
-//      case 2 => println("3")
-//      case 3 => println("4")
-//      case 4 => println("5")
-      case 5 if guard => println("6")
-//      case _ if guard => println("7")
-      case _ => println("8")
-    }
-
-//    (1: Any) match {
-      //          case List(1, 2, 3) if guard => println("0")
-      //          case Some(x) => println("1")
-      //          case List(1, 2, 3) => println("2")
-      //          case List(1, 2) => println("3")
-      //          case 1 => println("4")
-      //          case 2 => println("5")
-      //          case x :: xs if guard => println("6")
-      //          case Nil => println("7")
-//      case 2 if true => 8
-//      case _: Int => 9
-      //          case 3 => println("10")
-      //          case Some(x) => println("11")
-      //          case None => println("12")
-//    }
-
-//    (1: Any) match {
-//                case List(1, 2, 3) => println("0")
-      //          case Some(x) => println("1")
-//                case List(1, 2, 3) => println("2")
-      //          case List(1, 2) => println("3")
-      //          case 1 => println("4")
-      //          case 2 => println("5")
-      //          case x :: xs if guard => println("6")
-      //          case Nil => println("7")
-//      case 2 if true => 8
-//      case _: Int => 9
-      //          case 3 => println("10")
-      //          case Some(x) => println("11")
-      //          case None => println("12")
-//    }
-////val guard = true
-//    (1) match {
-////      case List(a, b, c) => 4// 1
-////      case List(3, 4, 5) => 5// 2
-////      case Nil => // 2
-////      case List(3, 4, 5) => // 2
-////      case List(3, 4, 5) => // 2
-////      case x :: xs => // 2
-////      case Nil if true => 8
-////      case _: List[AnyRef] if true => 3
-////      case _: List[AnyRef] => 4
-////      case _: String if true => 5
-////      case _: Some => 6
-////      case _: String => 7
-//
-////      case 6 if false     => 2// 3
-////      case 6 if guard => 3// 3
-////
-////      case 8 =>       7      // 4
-////      case 2 if true =>   5           // 4
-////      case _ if false =>       33       // 5
-////      case 2 =>   8          // 4
-////      case n: Int if true =>       45       // 5
-////      case n: Int =>       46       // 5
-////      case n: Int if true =>       44       // 5
-//      case _ =>   1          // 4
-//
-////
-////      case List(3, 6, 5) => 5// 2
-////      case 3 =>       6      // 4
-////      case 7 =>       86      // 4
-////      case 5 if true =>       84      // 4
-////      case n2 =>       44       // 5
-////      case 3 => 2
-////      case 3L =>    4         // 4
-////      case Some(a) if a == "a" => 3// 4
-////      case None          =>4
-////      case 2L =>     4        // 4
-////      case List(a, b, c) =>4 // 1
-////      case 4 =>        4     // 4
-////      case _ =>    4         // 4
-////      case 4L =>             // 4
-////      case 1L =>             // 4
-////      case 4 if true =>             // 4
-////      case 4 if false =>             // 4
-////      case _: Int =>4
-////      case _ => 1
-////      case Some(a) if a == "b" => // 4
-////      case Some(a) if a == "a" => // 4
-////      case _ if true =>
-////      case Some(1)  => // 4
-////      case Some(a)       => // 4
-////      case None          =>
-////      case n1: Int if true =>             // 5
-////      case n2: Int if false =>             // 5
-////      case _: Int =>    44         // 5
-////      case _ =>       33       // 5
-//    }
-  }
-}

From b4af143435b46b68a1ed759587f49c822df1f3c3 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 14:38:50 +0200
Subject: [PATCH 54/88] Run all tests with -optimise

---
 compiler/test/dotty/tools/vulpix/TestConfiguration.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
index 242160074cde..968bbf145585 100644
--- a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
+++ b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
@@ -52,7 +52,7 @@ object TestConfiguration {
 
   private val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,mixin,restoreScopes,labelDef")
 
-  val defaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath
+  val defaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath :+ "-optimise"
   val allowDeepSubtypes = defaultOptions diff Array("-Yno-deep-subtypes")
   val allowDoubleBindings = defaultOptions diff Array("-Yno-double-bindings")
   val picklingOptions = defaultOptions ++ Array(

From f7753458cedaea427efb4310e99caa0d8c291ec1 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 14:38:49 +0200
Subject: [PATCH 55/88] Formating / refactoring

---
 .../dotc/transform/linker/Analysis.scala      |  25 +-
 .../dotc/transform/linker/Simplify.scala      | 280 +++++++++---------
 2 files changed, 151 insertions(+), 154 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala b/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
index 6719acd57222..449fdcb42102 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
@@ -1,19 +1,12 @@
-package dotty.tools.dotc.transform.linker
+package dotty.tools.dotc
+package transform.linker
 
-import dotty.tools.dotc.{ast, core}
-import core._
-import Contexts._
-import dotty.tools.dotc.ast.Trees._
-import StdNames._
-import NameOps._
-import dotty.tools.dotc.ast.tpd
-import Symbols._
-import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.core.Types.{NoPrefix, TermRef, ThisType}
-import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
-import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo}
-import dotty.tools.dotc.transform.SymUtils._
-import Decorators._
+import ast.Trees._
+import ast.tpd
+import core.Contexts._
+import core.NameOps._
+import core.StdNames._
+import core.Symbols._
 
 object Analysis {
   import tpd._
@@ -56,7 +49,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) =>
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 5497b521da80..37a508e71d8f 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -1,25 +1,21 @@
-package dotty.tools.dotc.transform.linker
+package dotty.tools.dotc
+package transform.linker
 
-import dotty.tools.dotc.{ast, core}
 import core._
-import Contexts._
-import dotty.tools.dotc.ast.Trees._
-import StdNames._
-import NameOps._
-import dotty.tools.dotc.ast.tpd
-import Symbols._
-import dotty.tools.dotc.core.Phases.Phase
-import dotty.tools.dotc.core.Types.{ConstantType, ExprType, MethodType, MethodicType, NamedType, NoPrefix, NoType, TermRef, ThisType, Type}
-import dotty.tools.dotc.transform.{Erasure, TreeTransforms}
-import dotty.tools.dotc.transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
-import dotty.tools.dotc.transform.SymUtils._
-import Decorators._
-import dotty.tools.dotc.core.Constants.Constant
-import dotty.tools.dotc.core.DenotTransformers.IdentityDenotTransformer
-import dotty.tools.dotc.typer.ConstFold
-
+import core.Constants.Constant
+import core.Contexts._
+import core.Decorators._
+import core.DenotTransformers.IdentityDenotTransformer
+import core.NameOps._
+import core.StdNames._
+import core.Symbols._
+import core.Types._
+import ast.Trees._
+import ast.tpd
 import scala.collection.mutable
-import scala.collection.mutable.ListBuffer
+import transform.SymUtils._
+import transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
+import typer.ConstFold
 
 /** This phase consists of a series of small, simple, local optimizations
  *  applied as a fix point transformation over Dotty Trees.
@@ -36,25 +32,25 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   private var symmetricOperations: Set[Symbol] = null
   var optimize = false
 
-  override def prepareForUnit(tree: _root_.dotty.tools.dotc.ast.tpd.Tree)(implicit ctx: Context): TreeTransform = {
+  override def prepareForUnit(tree: Tree)(implicit ctx: Context): TreeTransform = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
     symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
     optimize = ctx.settings.optimise.value
     this
   }
 
-  private def desugarIdent(i: Ident)(implicit ctx: Context): Option[tpd.Select] = {
+  private def desugarIdent(i: Ident)(implicit ctx: Context): Option[Select] = {
     i.tpe match {
       case TermRef(prefix: TermRef, name) =>
-        Some(tpd.ref(prefix).select(i.symbol))
+        Some(ref(prefix).select(i.symbol))
       case TermRef(prefix: ThisType, name) =>
-        Some(tpd.This(prefix.cls).select(i.symbol))
+        Some(This(prefix.cls).select(i.symbol))
       case _ => None
     }
   }
 
   private def dropCasts(t: Tree)(implicit ctx: Context): Tree = t match {
-    //case TypeApply(aio@Select(rec, nm), _) if aio.symbol == defn.Any_asInstanceOf => dropCasts(rec)
+    // case TypeApply(aio@Select(rec, nm), _) if aio.symbol == defn.Any_asInstanceOf => dropCasts(rec)
     case Typed(t, tpe) => t
     case _ => t
   }
@@ -134,7 +130,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ,constantFold
   )
 
-  override def transformDefDef(tree: tpd.DefDef)(implicit ctx: Context, info: TransformerInfo): tpd.Tree = {
+  override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val ctx0 = ctx
     if (optimize && !tree.symbol.is(Flags.Label)) {
       implicit val ctx: Context = ctx0.withOwner(tree.symbol(ctx0))
@@ -144,9 +140,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       val erasureCompatibility = if (ctx.erasedTypes) AfterErasure else BeforeErasure
       while (rhs1 ne rhs0) {
         rhs1 = rhs0
-        val initialized = _optimizations.map(x =>x(ctx.withOwner(tree.symbol)))
-        var (names, erasureSupport , visitors, transformers) = unzip4(initialized)
-        // todo: fuse for performance
+        val initialized = _optimizations.map(x => x(ctx.withOwner(tree.symbol)))
+        var (names, erasureSupport, visitors, transformers) = unzip4(initialized)
+        // TODO: fuse for performance
         while (names.nonEmpty) {
           val nextVisitor = visitors.head
           val supportsErasure = erasureSupport.head
@@ -155,13 +151,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val nextTransformer = transformers.head()
             val name = names.head
             val rhst = new TreeMap() {
-              override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+              override def transform(tree: Tree)(implicit ctx: Context): Tree = {
                 val innerCtx = if (tree.isDef && tree.symbol.exists) ctx.withOwner(tree.symbol) else ctx
                 nextTransformer(ctx)(super.transform(tree)(innerCtx))
               }
             }.transform(rhs0)
-//            if (rhst ne rhs0)
-//              println(s"${tree.symbol} after ${name} became ${rhst.show}")
+            // if (rhst ne rhs0)
+            //   println(s"${tree.symbol} after ${name} became ${rhst.show}")
             rhs0 = rhst
           }
           names = names.tail
@@ -205,9 +201,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         if (!a.symbol.owner.is(Flags.Scala2x)) {
           if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
           else a.args.head
-        } else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
-          // todo: if args is an expression, this will evaluate it multiple times
-          // todo: if the static type is right, it does not mean it's not null
+        }
+        else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
+          // TODO: if args is an expression, this will evaluate it multiple times
+          // TODO: if the static type is right, it does not mean it's not null
           val accessors = a.args.head.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Flags.Method))
           val fields = accessors.map(x => a.args.head.select(x).ensureApplied)
           val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
@@ -252,7 +249,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    */
   val constantFold: Optimization = { implicit ctx: Context =>
     def preEval(t: Tree) = {
-      if (t.isInstanceOf[Literal] || t.isInstanceOf[CaseDef] || !isPureExpr(t)) t else {
+      if (t.isInstanceOf[Literal] || t.isInstanceOf[CaseDef] || !isPureExpr(t)) t
+      else {
         val s = ConstFold.apply(t)
         if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {
           val constant = s.tpe.asInstanceOf[ConstantType].value
@@ -316,27 +314,27 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }  else if (!thenp.const.booleanValue && elsep.const.booleanValue) {
           cond.select(defn.Boolean_!).ensureApplied
         } else ??? //should never happen because it would be similar
-//         the lower two are disabled, as it may make the isSimilar rule not apply for a nested structure of iffs.
-//         see the example below:
-    //        (b1, b2) match {
-    //          case (true, true) => true
-    //          case (false, false) => true
-    //          case _ => false
-    //        }
-//      case ift @ If(cond, thenp: Literal, elsep) if ift.tpe.derivesFrom(defn.BooleanClass) && thenp.const.booleanValue =>
-//        //if (thenp.const.booleanValue)
-//          cond.select(defn.Boolean_||).appliedTo(elsep)
-//        //else // thenp is false, this tree is bigger then the original
-//        //  cond.select(defn.Boolean_!).select(defn.Boolean_&&).appliedTo(elsep)
-//      case ift @ If(cond, thenp, elsep :Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && !elsep.const.booleanValue =>
-//        cond.select(defn.Boolean_&&).appliedTo(elsep)
-//        // the other case ins't handled intentionally. See previous case for explanation
+      //    the lower two are disabled, as it may make the isSimilar rule not apply for a nested structure of iffs.
+      //    see the example below:
+      //           (b1, b2) match {
+      //             case (true, true) => true
+      //             case (false, false) => true
+      //             case _ => false
+      //           }
+      // case ift @ If(cond, thenp: Literal, elsep) if ift.tpe.derivesFrom(defn.BooleanClass) && thenp.const.booleanValue =>
+      //   //if (thenp.const.booleanValue)
+      //     cond.select(defn.Boolean_||).appliedTo(elsep)
+      //   //else // thenp is false, this tree is bigger then the original
+      //   //  cond.select(defn.Boolean_!).select(defn.Boolean_&&).appliedTo(elsep)
+      // case ift @ If(cond, thenp, elsep :Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && !elsep.const.booleanValue =>
+      //   cond.select(defn.Boolean_&&).appliedTo(elsep)
+      //   // the other case ins't handled intentionally. See previous case for explanation
       case If(t@ Select(recv, _), thenp, elsep) if t.symbol eq defn.Boolean_! =>
-        tpd.If(recv, elsep, thenp)
+        If(recv, elsep, thenp)
       case If(t@ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
-        tpd.If(recv, elsep, thenp)
-      // todo: similar trick for comparisons.
-      // todo: handle comparison with min\max values
+        If(recv, elsep, thenp)
+      // TODO: similar trick for comparisons.
+      // TODO: handle comparison with min\max values
       case Apply(meth1 @ Select(Apply(meth2 @ Select(rec, _), Nil), _), Nil) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! =>
         rec
       case meth1 @ Select(meth2 @ Select(rec, _), _) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! && !ctx.erasedTypes =>
@@ -368,27 +366,27 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
             if (l.const.booleanValue) l
             else Block(lhs :: Nil, rhs)
-//          case (Literal(Constant(1)), _)    if sym == defn.Int_*  => rhs
-//          case (Literal(Constant(0)), _)    if sym == defn.Int_+  => rhs
-//          case (Literal(Constant(1L)), _)   if sym == defn.Long_* => rhs
-//          case (Literal(Constant(0L)), _)   if sym == defn.Long_+ => rhs
-//          // todo: same for float, double, short
-//          // todo: empty string concat
-//          // todo: disctribute & reorder constants
-//          // todo: merge subsequent casts
-//          case (_, Literal(Constant(1)))    if sym == defn.Int_/  => lhs
-//          case (_, Literal(Constant(1L)))   if sym == defn.Long_/ => lhs
-//          case (_, Literal(Constant(0)))    if sym == defn.Int_/  =>
-//            Block(List(lhs),
-//              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
-//          case (_, Literal(Constant(0L)))  if sym == defn.Long_/ =>
-//            Block(List(lhs),
-//              ref(defn.throwMethod).appliedTo(tpd.New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+          // case (Literal(Constant(1)), _)    if sym == defn.Int_*  => rhs
+          // case (Literal(Constant(0)), _)    if sym == defn.Int_+  => rhs
+          // case (Literal(Constant(1L)), _)   if sym == defn.Long_* => rhs
+          // case (Literal(Constant(0L)), _)   if sym == defn.Long_+ => rhs
+          // // TODO: same for float, double, short
+          // // TODO: empty string concat
+          // // TODO: disctribute & reorder constants
+          // // TODO: merge subsequent casts
+          // case (_, Literal(Constant(1)))    if sym == defn.Int_/  => lhs
+          // case (_, Literal(Constant(1L)))   if sym == defn.Long_/ => lhs
+          // case (_, Literal(Constant(0)))    if sym == defn.Int_/  =>
+          //   Block(List(lhs),
+          //     ref(defn.throwMethod).appliedTo(New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+          // case (_, Literal(Constant(0L)))  if sym == defn.Long_/ =>
+          //   Block(List(lhs),
+          //     ref(defn.throwMethod).appliedTo(New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
           case _ => t
         }
-      case t: Match if (t.selector.tpe.isInstanceOf[ConstantType] && t.cases.forall(x => x.pat.tpe.isInstanceOf[ConstantType] || (tpd.isWildcardArg(x.pat) && x.guard.isEmpty))) =>
+      case t: Match if (t.selector.tpe.isInstanceOf[ConstantType] && t.cases.forall(x => x.pat.tpe.isInstanceOf[ConstantType] || (isWildcardArg(x.pat) && x.guard.isEmpty))) =>
         val selectorValue = t.selector.tpe.asInstanceOf[ConstantType].value
-        val better = t.cases.find(x => tpd.isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
+        val better = t.cases.find(x => isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
         if (better.nonEmpty) better.get.body
         else t
       case t: Literal =>
@@ -407,7 +405,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ("constantFold", BeforeAndAfterErasure, NoVisitor, transformer)
   }
 
-  /** Inline" case classes as vals, this essentially (local) implements multi
+  /** Inline case classes as vals, this essentially (local) implements multi
    *  parameter value classes. The main motivation is to get ride of all the
    *  intermediate tuples coming from pattern matching expressions.
    */
@@ -424,7 +422,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           hasPerfectRHS(symbol) = true
         case Apply(fun, _) if fun.symbol.is(Flags.Label) && (fun.symbol ne symbol) =>
           checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + fun.symbol)
-          //assert(forwarderWritesTo.getOrElse(t.symbol, symbol) == symbol)
+          // assert(forwarderWritesTo.getOrElse(t.symbol, symbol) == symbol)
           forwarderWritesTo(t.symbol) = symbol
         case t: Ident if !t.symbol.owner.isClass && (t.symbol ne symbol) =>
           checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + t.symbol)
@@ -460,16 +458,16 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       val newMappings: Map[Symbol, Map[Symbol, Symbol]] =
         hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Flags.Method) && !x.is(Flags.Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is Flags.CaseClass))
-          .map{ refVal =>
-//          println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
-          var accessors = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // todo: drop mutable ones
-          if (accessors.isEmpty) accessors = refVal.info.classSymbol.caseAccessors
-          val productAccessors = (1 to accessors.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // todo: disambiguate
-          val newLocals = accessors.map(x =>
-            // todo: it would be nice to have an additional optimization that
-            // todo: is capable of turning those mutable ones into immutable in common cases
-            ctx.newSymbol(ctx.owner.enclosingMethod, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
-          )
+          .map { refVal =>
+            // println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
+            var accessors = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // TODO: drop mutable ones
+            if (accessors.isEmpty) accessors = refVal.info.classSymbol.caseAccessors
+            val productAccessors = (1 to accessors.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // TODO: disambiguate
+            val newLocals = accessors.map(x =>
+              // TODO: it would be nice to have an additional optimization that
+              // TODO: is capable of turning those mutable ones into immutable in common cases
+              ctx.newSymbol(ctx.owner.enclosingMethod, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
+            )
             val fieldMapping = accessors zip newLocals
             val productMappings = productAccessors zip newLocals
             (refVal, (fieldMapping ++ productMappings).toMap)
@@ -482,7 +480,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case tree@ If(_, thenp, elsep) => cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
           case Apply(sel , args) if sel.symbol.isConstructor && t.tpe.widenDealias == target.info.widenDealias.finalResultType.widenDealias =>
             val fieldsByAccessors = newMappings(target)
-            var accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)  // todo: when is this filter needed?
+            var accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)  // TODO: when is this filter needed?
             if (accessors.isEmpty) accessors = target.info.classSymbol.caseAccessors
             val assigns = (accessors zip args) map (x => ref(fieldsByAccessors(x._1)).becomes(x._2))
             val recreate = sel.appliedToArgs(accessors.map(x => ref(fieldsByAccessors(x))))
@@ -511,7 +509,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
 
       def followCases(t: Symbol, limit: Int = 0): Symbol = if (t.symbol.is(Flags.Label)) {
-        // todo: this can create cycles, see ./tests/pos/rbtree.scala
+        // TODO: this can create cycles, see ./tests/pos/rbtree.scala
         if (limit > 100 && limit > forwarderWritesTo.size + 1) NoSymbol
           // there may be cycles in labels, that never in the end write to a valdef(the value is always on stack)
           // there's not much we can do here, except finding such cases and bailing out
@@ -520,7 +518,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       } else t
 
       hasPerfectRHS.clear()
-      //checkGood.clear()
+      // checkGood.clear()
       gettersCalled.clear()
 
       val res: Context => Tree => Tree = {localCtx => (t: Tree) => t match {
@@ -535,7 +533,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           // break ValDef apart into fields + boxed value
           val newFields = newMappings(a.symbol).values.toSet
           Thicket(
-            newFields.map(x => tpd.ValDef(x.asTerm, tpd.defaultValue(x.symbol.info.widenDealias))).toList :::
+            newFields.map(x => ValDef(x.asTerm, defaultValue(x.symbol.info.widenDealias))).toList :::
               List(cpy.ValDef(a)(rhs = splitWrites(a.rhs, a.symbol))))
         case ass: Assign =>
           newMappings.get(ass.lhs.symbol) match {
@@ -564,7 +562,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       t match {
         case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
         case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
-        case TypeApply(fun @Select(x, _), List(tp)) if fun.symbol eq defn.Any_isInstanceOf =>
+        case TypeApply(fun @ Select(x, _), List(tp)) if fun.symbol eq defn.Any_isInstanceOf =>
           if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
             (x.symbol, tp.tpe) :: Nil
           else Nil
@@ -603,7 +601,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           y + ((x._1, x._2 :: y.getOrElse(x._1, Nil)))
         )
         val dropGoodCastsInStats = new TreeMap() {
-          override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = super.transform(tree) match {
+          override def transform(tree: Tree)(implicit ctx: Context): Tree = super.transform(tree) match {
             case t: Block =>
               val nstats = t.stats.filterConserve({
                  case TypeApply(fun @ Select(rec, _), List(tp)) if fun.symbol == defn.Any_asInstanceOf =>
@@ -653,7 +651,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
         !set.exists(x => !initializedVals.contains(x))
       }
-
     }
     val visitor: Visitor = {
       case vd: ValDef =>
@@ -697,8 +694,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           val sym = check.symbol
           if ( ((sym == defn.Object_eq) || (sym == defn.Object_ne)) &&
             ((isNullLiteral(lhs) && isGood(rhs.symbol)) || (isNullLiteral(rhs) && isGood(lhs.symbol)))) {
-            if (sym == defn.Object_eq) Block(List(lhs, rhs), tpd.Literal(Constant(false)))
-            else if(sym == defn.Object_ne) Block(List(lhs, rhs), tpd.Literal(Constant(true)))
+            if (sym == defn.Object_eq) Block(List(lhs, rhs), Literal(Constant(false)))
+            else if(sym == defn.Object_ne) Block(List(lhs, rhs), Literal(Constant(true)))
             else check
           } else check
         case t => t
@@ -734,8 +731,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
     t match {
-      case t: Literal => EmptyTree
-      case t: This => EmptyTree
+      case t: Literal =>
+        EmptyTree
+      case t: This =>
+        EmptyTree
       case Typed(exp, tpe) =>
         keepOnlySideEffects(exp)
       case t @ If(cond, thenp, elsep) =>
@@ -743,19 +742,21 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val nelsep = keepOnlySideEffects(elsep)
         if (thenp.isEmpty && elsep.isEmpty) keepOnlySideEffects(cond)
         else cpy.If(t)(
-          thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else  tpd.unitLiteral),
-          elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else  tpd.unitLiteral))
-      case Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isProductAccessorName) ||
-        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))=>
-        keepOnlySideEffects(rec) // accessing a field of a product
-      case Select(qual, _) if !t.symbol.is(Flags.Mutable | Flags.Lazy) && (!t.symbol.is(Flags.Method) || t.symbol.isGetter) =>
+          thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else unitLiteral),
+          elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else unitLiteral))
+      case Select(rec, _) if
+        (t.symbol.isGetter && !t.symbol.is(Flags.Mutable | Flags.Lazy)) ||
+        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
+        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
+          keepOnlySideEffects(rec) // accessing a field of a product
+      case Select(qual, _) if !t.symbol.is(Flags.Mutable | Flags.Lazy) && !t.symbol.is(Flags.Method) =>
         keepOnlySideEffects(qual)
-      case Block(List(t: DefDef), s: Closure) => EmptyTree
-      case bl@Block(stats, expr) =>
+      case Block(List(t: DefDef), s: Closure) =>
+        EmptyTree
+      case bl @ Block(stats, expr) =>
         val stats1 = stats.mapConserve(keepOnlySideEffects)
         val stats2 = if (stats1 ne stats) stats1.filter(x=>x ne EmptyTree) else stats1
-        val expr2: tpd.Tree = expr match {
+        val expr2: Tree = expr match {
           case t: Literal if t.tpe.derivesFrom(defn.UnitClass) => expr
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
@@ -770,7 +771,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         // invalidates the denotation cache. Because this optimization only
         // operates locally, this should be fine.
         val denot = app.fun.symbol.denot
-        //println(s"replacing ${app.symbol}")
+        // println(s"replacing ${app.symbol}")
         if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
           val newLabelType = app.symbol.info match {
             case mt: MethodType =>
@@ -802,7 +803,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ =>
             rec :: args.map(keepOnlySideEffects)
         }
-        Block(prefix, tpd.unitLiteral)
+        Block(prefix, unitLiteral)
       case t @ TypeApply(Select(rec, _), List(testType)) if t.symbol.eq(defn.Any_asInstanceOf) && testType.tpe.widenDealias.typeSymbol.exists =>
         val receiverType = TypeErasure.erasure(rec.tpe)
         val erazedTestedType = TypeErasure.erasure(testType.tpe)
@@ -815,7 +816,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   /** Removes side effect free statements in blocks. */
   val dropNoEffects: Optimization = { implicit ctx: Context =>
-
     val transformer: Transformer = () => localCtx => {
       case Block(Nil, expr) => expr
       case a: Block  =>
@@ -835,10 +835,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case a: DefDef =>
         if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
           def insertUnit(t: Tree) = {
-            if (!t.tpe.derivesFrom(defn.UnitClass)) Block(t :: Nil, tpd.unitLiteral)
+            if (!t.tpe.derivesFrom(defn.UnitClass)) Block(t :: Nil, unitLiteral)
             else t
           }
-          cpy.DefDef(a)(rhs = insertUnit(keepOnlySideEffects(a.rhs)), tpt = tpd.TypeTree(defn.UnitType))
+          cpy.DefDef(a)(rhs = insertUnit(keepOnlySideEffects(a.rhs)), tpt = TypeTree(defn.UnitType))
         } else a
       case t => t
     }
@@ -865,8 +865,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case a: Apply =>
         defined.get(a.symbol) match {
           case None => a
-          case Some(defDef) if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramTypess == List(Nil)=>
-            //println(s"Inlining ${defDef.name}")
+          case Some(defDef) if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramInfoss == List(Nil) =>
+            // println(s"Inlining ${defDef.name}")
             defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
           case Some(defDef) if defDef.rhs.isInstanceOf[Literal] =>
             defDef.rhs
@@ -874,11 +874,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             a
         }
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
-        //println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
+        // println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
         defined.put(a.symbol, a)
         EmptyTree
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 0 && defined.contains(a.symbol)) =>
-        //println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
+        // println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
         EmptyTree
       case t => t
     }
@@ -894,8 +894,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
         defdef.rhs match {
           case Apply(t, args) if t.symbol.is(Flags.Label) &&
-            TypeErasure.erasure(defdef.symbol.info.finalResultType).classSymbol == TypeErasure.erasure(t.symbol.info.finalResultType).classSymbol
-            && args.size == defdef.vparamss.map(_.size).sum && (args zip defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol)  && !(defdef.symbol eq t.symbol) =>
+            TypeErasure.erasure(defdef.symbol.info.finalResultType).classSymbol ==
+            TypeErasure.erasure(t.symbol.info.finalResultType).classSymbol             &&
+            args.size == defdef.vparamss.map(_.size).sum                               &&
+            args.zip(defdef.vparamss.flatten).forall(x => x._1.symbol eq x._2.symbol)  &&
+            !(defdef.symbol eq t.symbol) =>
               defined(defdef.symbol) = t.symbol
           case _ =>
         }
@@ -910,7 +913,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             ref(fwd).appliedToArgs(a.args)
         }
       case a: DefDef if defined.contains(a.symbol) =>
-        //println(s"dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
+        // println(s"dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
         EmptyTree
       case t => t
     }
@@ -977,7 +980,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val secondWrite: mutable.Map[Symbol, Assign] = mutable.Map()
     val visitor: Visitor = {
       case t: ValDef if t.symbol.is(Flags.Mutable, Flags.Lazy) && !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
-        if (tpd.isPureExpr(t.rhs))
+        if (isPureExpr(t.rhs))
           defined(t.symbol) = t
       case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
         if (!firstWrite.contains(t.symbol)) firstRead(t.symbol) = t
@@ -999,10 +1002,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val transformer: Transformer = () => localCtx => {
       val transformation: Tree => Tree = {
         case t: Block => // drop non-side-effecting stats
-          val valdefs = t.stats.filter {
-            case t: ValDef if defined.contains(t.symbol) => true
-            case _ => false
-          }.asInstanceOf[List[ValDef]]
+          val valdefs = t.stats.collect {
+            case t: ValDef if defined.contains(t.symbol) => t
+          }
 
           val assigns = t.stats.filter {
             case t @ Assign(lhs, r) =>
@@ -1024,7 +1026,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               case Some(vd) =>
                 val newD = vd.symbol.asSymDenotation.copySymDenotation(initFlags = vd.symbol.flags.&~(Flags.Mutable))
                 newD.installAfter(this)
-                tpd.ValDef(vd.symbol.asTerm, t.rhs)
+                ValDef(vd.symbol.asTerm, t.rhs)
               case None => t
             }
             case x => x
@@ -1047,8 +1049,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    *
    *  def f(x, y) = f(x + y + 1, x - y - 1)
    *
-   *  In scalac the above is optimized using a by code trick which cannot be
-   *  expressed in bytecode. In the example above, x can be turned into a var
+   *  In scalac the above is optimized using a bytecode trick which cannot be
+   *  expressed in source code. In the example above, x can be turned into a var
    *  by first doing a DUP to push the current value onto the stack. This
    *  introduces a tight coupling between backend and tqilreq which we prefer
    *  to avoid in dotty.
@@ -1058,7 +1060,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val defined = collection.mutable.HashSet[Symbol]()
     val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
     val visitor: Visitor = {
-      case valdef: ValDef if !valdef.symbol.is(Flags.Param) && !valdef.symbol.is(Flags.Mutable | Flags.Module | Flags.Lazy) && (valdef.symbol.exists && !valdef.symbol.owner.isClass) =>
+      case valdef: ValDef if !valdef.symbol.is(Flags.Param) &&
+                             !valdef.symbol.is(Flags.Mutable | Flags.Module | Flags.Lazy) &&
+                             valdef.symbol.exists && !valdef.symbol.owner.isClass =>
         defined += valdef.symbol
 
         dropCasts(valdef.rhs) match {
@@ -1072,7 +1076,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         timesUsed.put(symIfExists, b4 + 1)
 
       case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
-        //todo: handle params after constructors. Start changing public signatures by eliminating unused arguments.
+        // TODO: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 
       case t: RefTree =>
@@ -1087,19 +1091,19 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val rhs = dropCasts(x._2)
         rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Flags.Method) && !rhs.symbol.is(Flags.Mutable))
       }
-      // todo: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
+      // TODO: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 
       val copiesToReplaceAsUsedOnce =
         timesUsed.filter(x => x._2 == 1).
           flatMap(x => copies.get(x._1) match {
-            case Some(tr) => List((x._1, tr));
+            case Some(tr) => List((x._1, tr))
             case None => Nil
           })
 
       val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce
 
       val deepReplacer = new TreeMap() {
-        override def transform(tree: tpd.Tree)(implicit ctx: Context): tpd.Tree = {
+        override def transform(tree: Tree)(implicit ctx: Context): Tree = {
           def loop(tree: Tree):Tree  =
             tree match {
               case t: RefTree if replacements.contains(t.symbol) =>
@@ -1112,10 +1116,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       val transformation: Tree => Tree = {
         case t: ValDef if valsToDrop.contains(t.symbol) =>
-          //println(s"droping definition of ${t.symbol.showFullName} as not used")
+          // println(s"dropping definition of ${t.symbol.showFullName} as not used")
           t.rhs.changeOwner(t.symbol, t.symbol.owner)
         case t: ValDef if replacements.contains(t.symbol) =>
-          //println(s"droping definition of ${t.symbol.showFullName} as an alias")
+          // println(s"dropping definition of ${t.symbol.showFullName} as an alias")
           EmptyTree
         case t: Block => // drop non-side-effecting stats
           t
@@ -1127,7 +1131,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
               case t: NamedType =>
                 t.derivedSelect(newPrefix.tpe)
             }
-            tpd.New(newTpt)
+            New(newTpt)
           }
           else t
         case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.is(Flags.Param) && !t.symbol.is(Flags.Mutable) =>
@@ -1208,11 +1212,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }
 
   private def unzip4[A, B, C, D](seq: Seq[(A, B, C, D)]): (Seq[A], Seq[B], Seq[C], Seq[D]) = {
-    val listBuilderA = new ListBuffer[A]()
-    val listBuilderB = new ListBuffer[B]()
-    val listBuilderC = new ListBuffer[C]()
-    val listBuilderD = new ListBuffer[D]()
-    seq.foreach{x =>
+    val listBuilderA = new mutable.ListBuffer[A]()
+    val listBuilderB = new mutable.ListBuffer[B]()
+    val listBuilderC = new mutable.ListBuffer[C]()
+    val listBuilderD = new mutable.ListBuffer[D]()
+    seq.foreach { x =>
       listBuilderA += x._1
       listBuilderB += x._2
       listBuilderC += x._3

From c42a944d92d1fd05e6c18e1c834480cc44d46e22 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 14:38:49 +0200
Subject: [PATCH 56/88] Remove usage of -optimise in ClassfileParser

The test suite fails on master with -optimise without this change
---
 .../src/dotty/tools/dotc/core/classfile/ClassfileParser.scala   | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
index c23ff6d2affe..f89681204054 100644
--- a/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
+++ b/compiler/src/dotty/tools/dotc/core/classfile/ClassfileParser.scala
@@ -174,7 +174,7 @@ class ClassfileParser(
       if (method) Flags.Method | methodTranslation.flags(jflags)
       else fieldTranslation.flags(jflags)
     val name = pool.getName(in.nextChar)
-    if (!(sflags is Flags.Private) || name == nme.CONSTRUCTOR || ctx.settings.optimise.value) {
+    if (!(sflags is Flags.Private) || name == nme.CONSTRUCTOR) {
       val member = ctx.newSymbol(
         getOwner(jflags), name, sflags, memberCompleter, coord = start)
       getScope(jflags).enter(member)

From ef2d967351c17b7d6b6ef2b1dcccd703a8d5fca6 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 15:16:07 +0200
Subject: [PATCH 57/88] Fix a few bugs in Simplify

---
 .../dotc/transform/linker/Simplify.scala      | 81 ++++++++++++-------
 1 file changed, 53 insertions(+), 28 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 37a508e71d8f..f758c7b8e7ef 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -87,6 +87,17 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case None => true
       }
     case t: This => true
+    // null => false, or the following fails devalify:
+    // trait I {
+    //   def foo: Any = null
+    // }
+    // object Main {
+    //   def main = {
+    //     val s: I = null
+    //     s.foo
+    //   }
+    // }
+    case Literal(Constant(null)) => false
     case t: Literal => true
     case _ => false
   }
@@ -114,21 +125,21 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    */
   type Optimization = (Context) => (String, ErasureCompatibility, Visitor, Transformer)
 
-  private lazy val _optimizations: Seq[Optimization] = Seq(
-    inlineCaseIntrinsics
-    ,removeUnnecessaryNullChecks
-    ,inlineOptions
-    ,inlineLabelsCalledOnce
-    ,valify
-    ,devalify
-    ,jumpjump
-    ,dropGoodCasts
-    ,dropNoEffects
-    ,inlineLocalObjects // followCases needs to be fixed, see ./tests/pos/rbtree.scala
-    /*, varify*/  // varify could stop other transformations from being applied. postponed.
-    //, bubbleUpNothing
-    ,constantFold
-  )
+  private lazy val _optimizations: Seq[Optimization] =
+    inlineCaseIntrinsics        ::
+    removeUnnecessaryNullChecks ::
+    inlineOptions               ::
+    inlineLabelsCalledOnce      ::
+    valify                      ::
+    devalify                    ::
+    jumpjump                    ::
+    dropGoodCasts               ::
+    dropNoEffects               ::
+    // inlineLocalObjects          :: // followCases needs to be fixed, see ./tests/pos/rbtree.scala
+    // varify                      :: // varify could stop other transformations from being applied. postponed.
+    // bubbleUpNothing             ::
+    constantFold                ::
+    Nil
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val ctx0 = ctx
@@ -184,8 +195,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    */
   val inlineCaseIntrinsics: Optimization = { implicit ctx: Context =>
     val transformer: Transformer = () => localCtx => {
-      case a: Apply if !a.tpe.isInstanceOf[MethodicType] && a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
-        (a.symbol.name == nme.apply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
+      case a: Apply if !a.tpe.isInstanceOf[MethodicType]                 &&
+                       a.symbol.is(Flags.Synthetic)                      &&
+                       a.symbol.owner.is(Flags.Module)                   &&
+                       (a.symbol.name == nme.apply)                      &&
+                       a.symbol.owner.companionClass.is(Flags.CaseClass) &&
+                       !a.tpe.derivesFrom(defn.EnumClass)                &&
+                       isPureExpr(a.tree) =>
         def unrollArgs(t: Tree, l: List[List[Tree]]): List[List[Tree]] = t match {
           case Apply(t, args) => unrollArgs(t, args :: l)
           case _ => l
@@ -195,9 +211,15 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case head :: tail => rollInArgs(tail, fun.appliedToArgs(head))
           case _ => fun
         }
-        rollInArgs(argss.tail, tpd.New(a.tpe.dealias, argss.head))
-      case a: Apply if a.symbol.is(Flags.Synthetic) && a.symbol.owner.is(Flags.Module) &&
-        (a.symbol.name == nme.unapply) && a.symbol.owner.companionClass.is(Flags.CaseClass) =>
+        val constructor = a.symbol.owner.companionClass.primaryConstructor.asTerm
+        rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head))
+
+      case a: Apply if a.symbol.is(Flags.Synthetic)                      &&
+                       a.symbol.owner.is(Flags.Module)                   &&
+                       (a.symbol.name == nme.unapply)                    &&
+                       a.symbol.owner.companionClass.is(Flags.CaseClass) &&
+                       !a.tpe.derivesFrom(defn.EnumClass)                &&
+                       isPureExpr(a.tree) =>
         if (!a.symbol.owner.is(Flags.Scala2x)) {
           if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
           else a.args.head
@@ -210,14 +232,17 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
 
           if (fields.tail.nonEmpty) {
-            val tplAlloc = tpd.New(tplType, fields)
-            tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
-          } else { // scalac does not have tupple1
-            tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), fields.head :: Nil)
+            val tplAlloc = New(tplType, fields)
+            New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
+          } else { // scalac does not have Tuple1
+            New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), fields.head :: Nil)
           }
         }
         else a
-      case a: Apply if (a.symbol.name == nme.unapplySeq) && a.symbol.owner.derivesFrom(SeqFactoryClass) && a.symbol.extendedOverriddenSymbols.isEmpty =>
+      case a: Apply if (a.symbol.name == nme.unapplySeq)           &&
+                       a.symbol.owner.derivesFrom(SeqFactoryClass) &&
+                       a.symbol.extendedOverriddenSymbols.isEmpty  &&
+                       isPureExpr(a.tree) =>
         def reciever(t: Tree): Type = t match {
           case t: Apply => reciever(t.fun)
           case t: TypeApply => reciever(t.fun)
@@ -231,7 +256,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
         val recv = reciever(a)
         if (recv.typeSymbol.is(Flags.Module))
-          tpd.New(a.tpe.dealias.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
+          New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
         else a
       case t => t
     }
@@ -682,7 +707,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t: Tree =>
     }
 
-    @inline def isNullLiteral(tree: Tree) = tree match {
+    def isNullLiteral(tree: Tree) = tree match {
       case literal: Literal =>
         literal.const.tag == Constants.NullTag
       case _ => false
@@ -982,7 +1007,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t: ValDef if t.symbol.is(Flags.Mutable, Flags.Lazy) && !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
         if (isPureExpr(t.rhs))
           defined(t.symbol) = t
-      case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
+      case t: RefTree if t.symbol.exists && !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
         if (!firstWrite.contains(t.symbol)) firstRead(t.symbol) = t
       case t @ Assign(l, expr) if  !l.symbol.is(Flags.Method) && !l.symbol.owner.isClass =>
         if (!firstRead.contains(l.symbol)) {

From d255b32b49042df298058aec9461b4fda67c03d5 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Fri, 28 Apr 2017 14:38:49 +0200
Subject: [PATCH 58/88] Expose tpd problem, temporary .toString hack

The situation is a follows:

Without this commit `testOnly dotty.tools.dotc.CompilationTests -- *testPickling` fail with more precise types after pickling.

Reverting tpd.scala to master breaks the "tree referencial equiality" condition used in Simplify to detect a fix point. For example `vulpix t7336.scala` (this one also requires the Skolem#toString change).

This hack is sufficent for Simplify to reach its fix points without breaking pickling...

[SQUASH] [TODO] fix tpd .toString hack
---
 compiler/src/dotty/tools/dotc/ast/tpd.scala | 32 ++++++++++++++-------
 1 file changed, 21 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index c601530e9f85..348d667dec53 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -473,10 +473,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
+      // @Dmitry: current implementation in master:
+      // ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
       val untyped = untpd.cpy.Apply(tree)(fun, args)
-      if (untyped ne tree)
-        ta.assignType(untyped, fun, args)
-      else tree.asInstanceOf[Apply]
+      val typed   = ta.assignType(untyped, fun, args)
+      if (untyped.ne(tree) || tree.tpe.toString != typed.tpe.toString)
+        typed
+      else
+        tree.asInstanceOf[Apply]
     }
       // Note: Reassigning the original type if `fun` and `args` have the same types as before
       // does not work here: The computed type depends on the widened function type, not
@@ -484,12 +488,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       // same but its widened type might change.
 
     override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
+      // @Dmitry: current implementation in master:
+      // ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
       val untyped = untpd.cpy.TypeApply(tree)(fun, args)
-      if (untyped ne tree)
-        ta.assignType(untyped, fun, args)
-      else tree.asInstanceOf[TypeApply]
+      val typed   = ta.assignType(untyped, fun, args)
+      if (untyped.ne(tree) || tree.tpe.toString != typed.tpe.toString)
+        typed
+      else
+        tree.asInstanceOf[TypeApply]
     }
-    // FIXME
       // Same remark as for Apply
 
     override def Literal(tree: Tree)(const: Constant)(implicit ctx: Context): Literal =
@@ -524,11 +531,14 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
+      // @Dmitry: current implementation in master:
+      // ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
       val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
-      if (untyped ne tree)
-        ta.assignType(untyped, meth, tpt)
-      else tree.asInstanceOf[Closure]
-
+      val typed   = ta.assignType(untyped, meth, tpt)
+      if (untyped.ne(tree) || tree.tpe.toString != typed.tpe.toString)
+        typed
+      else
+        tree.asInstanceOf[Closure]
     }
       // Same remark as for Apply
 

From 4763a36b51664a31940b935179ad4852954a5b24 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Thu, 11 May 2017 11:38:12 +0200
Subject: [PATCH 59/88] Work in progress

3 failing tests left:

tests/run/t8933c.scala
tests/pos/t348plus.scala
dotty1 from idempotency1
---
 compiler/src/dotty/tools/dotc/Compiler.scala  |   5 +-
 .../dotty/tools/dotc/config/Printers.scala    |   1 +
 .../src/dotty/tools/dotc/core/Scopes.scala    |   8 +-
 .../dotc/transform/linker/Simplify.scala      | 193 ++++++++++--------
 compiler/test/dotc/tests.scala                |   4 +-
 .../dotty/tools/dotc/CompilationTests.scala   |   4 +-
 .../tools/vulpix/TestConfiguration.scala      |   2 +-
 tests/pos/bubbleUpNothing.scala               |  71 +++++++
 tests/pos/devalify.scala                      |  34 +++
 9 files changed, 234 insertions(+), 88 deletions(-)
 create mode 100644 tests/pos/bubbleUpNothing.scala
 create mode 100644 tests/pos/devalify.scala

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 11b94c9e0264..71e197a8e4e3 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/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
diff --git a/compiler/src/dotty/tools/dotc/config/Printers.scala b/compiler/src/dotty/tools/dotc/config/Printers.scala
index a77607d187e8..a8be043ea084 100644
--- a/compiler/src/dotty/tools/dotc/config/Printers.scala
+++ b/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
 }
diff --git a/compiler/src/dotty/tools/dotc/core/Scopes.scala b/compiler/src/dotty/tools/dotc/core/Scopes.scala
index 92ffb76d6bb1..a684a36838d1 100644
--- a/compiler/src/dotty/tools/dotc/core/Scopes.scala
+++ b/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
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index f758c7b8e7ef..f59e4d1aff33 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -16,6 +16,7 @@ import scala.collection.mutable
 import transform.SymUtils._
 import transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
 import typer.ConstFold
+import dotty.tools.dotc.config.Printers.simplify
 
 /** This phase consists of a series of small, simple, local optimizations
  *  applied as a fix point transformation over Dotty Trees.
@@ -56,15 +57,21 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   }
 
   private def readingOnlyVals(t: Tree)(implicit ctx: Context): Boolean = dropCasts(t) match {
-    case Typed(exp, tpe) => readingOnlyVals(exp)
-    case TypeApply(fun @Select(rec, _), List(tp))
-      if (fun.symbol eq defn.Any_asInstanceOf) && rec.tpe.derivesFrom(TypeErasure.erasure(tp.tpe).classSymbol) =>
-      readingOnlyVals(rec)
+    case Typed(exp, _) => readingOnlyVals(exp)
+    case TypeApply(fun @ Select(rec, _), List(tp)) =>
+      if ((fun.symbol eq defn.Any_asInstanceOf) && rec.tpe.derivesFrom(tp.tpe.classSymbol))
+        readingOnlyVals(rec)
+      else false
     case Apply(Select(rec, _), Nil) =>
-      if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
-      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName)
-        readingOnlyVals(rec) // accessing a field of a product
-      else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
+      def isGetterOfAImmutableField = t.symbol.isGetter && !t.symbol.is(Flags.Mutable)
+      def isCaseClassWithVar        = t.symbol.info.decls.exists(_.is(Flags.Mutable))
+      def isAccessingProductField   = t.symbol.exists                               &&
+                                      t.symbol.owner.derivesFrom(defn.ProductClass) &&
+                                      t.symbol.owner.is(Flags.CaseClass)            &&
+                                      t.symbol.name.isSelectorName                  &&
+                                      !isCaseClassWithVar // Conservative Covers case class A(var x: Int)
+      def isImmutableCaseAccessor   = t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)
+      if (isGetterOfAImmutableField || isAccessingProductField || isImmutableCaseAccessor)
         readingOnlyVals(rec)
       else false
     case Select(rec, _) if t.symbol.is(Flags.Method) =>
@@ -127,8 +134,14 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private lazy val _optimizations: Seq[Optimization] =
     inlineCaseIntrinsics        ::
-    removeUnnecessaryNullChecks ::
+    removeUnnecessaryNullChecks :: // Doesn't seams to work AfterErasure
     inlineOptions               ::
+       // Tests that fail when enabled AfterErasure, to be investigated?
+       // ../tests/run/Course-2002-04.scala failed
+       // ../tests/run/t2005.scala failed
+       // ../tests/run/optimizer-array-load.scala failed
+       // ../tests/pos/virtpatmat_exist1.scala failed
+       // ../tests/pos/t1133.scala failed
     inlineLabelsCalledOnce      ::
     valify                      ::
     devalify                    ::
@@ -137,7 +150,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     dropNoEffects               ::
     // inlineLocalObjects          :: // followCases needs to be fixed, see ./tests/pos/rbtree.scala
     // varify                      :: // varify could stop other transformations from being applied. postponed.
-    // bubbleUpNothing             ::
+    bubbleUpNothing             ::
+      // Still need to import the tailRec thing
+      // t2429.scala
+      // constraining-lub.scala
     constantFold                ::
     Nil
 
@@ -167,8 +183,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
                 nextTransformer(ctx)(super.transform(tree)(innerCtx))
               }
             }.transform(rhs0)
-            // if (rhst ne rhs0)
-            //   println(s"${tree.symbol} after ${name} became ${rhst.show}")
+            if (rhst ne rhs0) {
+              simplify.println(s"${tree.symbol} was simplified by ${name}: ${rhs0.show}")
+              simplify.println(s"became: ${rhst.show}")
+            }
             rhs0 = rhst
           }
           names = names.tail
@@ -435,10 +453,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    *  intermediate tuples coming from pattern matching expressions.
    */
   val inlineLocalObjects: Optimization = { implicit ctx: Context =>
-    val hasPerfectRHS = collection.mutable.HashMap[Symbol, Boolean]() // in the end only calls constructor. Reason for unconditional inlining
-    val checkGood = collection.mutable.HashMap[Symbol, Set[Symbol]]() // if all values have perfect RHS than key has perfect RHS
-    val forwarderWritesTo = collection.mutable.HashMap[Symbol, Symbol]()
-    val gettersCalled = collection.mutable.HashSet[Symbol]()
+    // In the end only calls constructor. Reason for unconditional inlining
+    val hasPerfectRHS = mutable.HashMap[Symbol, Boolean]()
+    // If all values have perfect RHS than key has perfect RHS
+    val checkGood = mutable.HashMap[Symbol, Set[Symbol]]()
+    val forwarderWritesTo = mutable.HashMap[Symbol, Symbol]()
+    val gettersCalled = mutable.HashSet[Symbol]()
     def followTailPerfect(t: Tree, symbol: Symbol): Unit = {
       t match {
         case Block(_, expr) => followTailPerfect(expr, symbol)
@@ -484,7 +504,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       val newMappings: Map[Symbol, Map[Symbol, Symbol]] =
         hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Flags.Method) && !x.is(Flags.Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is Flags.CaseClass))
           .map { refVal =>
-            // println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
+            simplify.println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
             var accessors = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // TODO: drop mutable ones
             if (accessors.isEmpty) accessors = refVal.info.classSymbol.caseAccessors
             val productAccessors = (1 to accessors.length).map(i => refVal.info.member(nme.productAccessorName(i)).symbol) // TODO: disambiguate
@@ -505,20 +525,20 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case tree@ If(_, thenp, elsep) => cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
           case Apply(sel , args) if sel.symbol.isConstructor && t.tpe.widenDealias == target.info.widenDealias.finalResultType.widenDealias =>
             val fieldsByAccessors = newMappings(target)
-            var accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)  // TODO: when is this filter needed?
+            var accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter) // TODO: when is this filter needed?
             if (accessors.isEmpty) accessors = target.info.classSymbol.caseAccessors
             val assigns = (accessors zip args) map (x => ref(fieldsByAccessors(x._1)).becomes(x._2))
             val recreate = sel.appliedToArgs(accessors.map(x => ref(fieldsByAccessors(x))))
             Block(assigns, recreate)
           case Apply(fun, _) if fun.symbol.is(Flags.Label) =>
-            t // do nothing. it will do on its own
+            t // Do nothing. It will do on its own.
           case t: Ident if !t.symbol.owner.isClass && newMappings.contains(t.symbol) && t.symbol.info.classSymbol == target.info.classSymbol =>
             val fieldsByAccessorslhs = newMappings(target)
             val fieldsByAccessorsrhs = newMappings(t.symbol)
             val accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter)
             val assigns = accessors map (x => ref(fieldsByAccessorslhs(x)).becomes(ref(fieldsByAccessorsrhs(x))))
             Block(assigns, t)
-          // if t is itself split, push writes
+          // If `t` is itself split, push writes.
           case _ =>
             evalOnce(t){ev =>
               if (ev.tpe.derivesFrom(defn.NothingClass)) ev
@@ -528,7 +548,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
                 val assigns = accessors map (x => ref(fieldsByAccessors(x)).becomes(ev.select(x)))
                 Block(assigns, ev)
               }
-            } // need to eval-once and update fields
+            } // Need to eval-once and update fields.
 
         }
       }
@@ -536,7 +556,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       def followCases(t: Symbol, limit: Int = 0): Symbol = if (t.symbol.is(Flags.Label)) {
         // TODO: this can create cycles, see ./tests/pos/rbtree.scala
         if (limit > 100 && limit > forwarderWritesTo.size + 1) NoSymbol
-          // there may be cycles in labels, that never in the end write to a valdef(the value is always on stack)
+          // There may be cycles in labels, that never in the end write to a valdef(the value is always on stack)
           // there's not much we can do here, except finding such cases and bailing out
           // there may not be a cycle bigger that hashmapSize > 1
         else followCases(forwarderWritesTo.getOrElse(t.symbol, NoSymbol), limit + 1)
@@ -555,7 +575,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           }
         case a: ValDef if toSplit.contains(a.symbol) =>
           toSplit -= a.symbol
-          // break ValDef apart into fields + boxed value
+          // Break ValDef apart into fields + boxed value
           val newFields = newMappings(a.symbol).values.toSet
           Thicket(
             newFields.map(x => ValDef(x.asTerm, defaultValue(x.symbol.info.widenDealias))).toList :::
@@ -601,7 +621,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       t match {
         case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
         case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
-        case Apply(fun @Select(x, _), List(tp)) if fun.symbol eq defn.Object_ne =>
+        case Apply(fun @ Select(x, _), List(tp)) if fun.symbol eq defn.Object_ne =>
           if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
             x.symbol :: Nil
           else Nil
@@ -617,7 +637,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    *  - Simplify (a == null) and (a != null) when the result is statically known
    */
   val dropGoodCasts: Optimization = { implicit ctx: Context =>
-
     val transformer: Transformer = () => localCtx => {
       case t @ If(cond, thenp, elsep) =>
         val newTypeTested = collectTypeTests(cond)
@@ -681,9 +700,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case vd: ValDef =>
         val rhs = vd.rhs
         val rhsName = rhs.symbol.name
-        if (!vd.symbol.is(Flags.Mutable) &&
-          !rhs.isEmpty) {
-
+        if (!vd.symbol.is(Flags.Mutable) && !rhs.isEmpty) {
           def checkNonNull(t: Tree, target: Symbol): Boolean = t match {
             case Block(_ , expr) => checkNonNull(expr, target)
             case If(_, thenp, elsep) => checkNonNull(thenp, target) && checkNonNull(elsep, target)
@@ -727,7 +744,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
       transformation
     }
-    ("removeUnnecessaryNullChecks", BeforeAndAfterErasure, visitor,
+    ("removeUnnecessaryNullChecks", BeforeErasure, visitor,
       transformer)
   }
 
@@ -737,21 +754,44 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    *  compiler will often be able to reduce them to a single main with ???...
    */
   val bubbleUpNothing: Optimization = { implicit ctx: Context =>
+    object Notathing {
+      def unapply(t: Tree): Option[Tree] = Option(lookup(t))
+      def lookup(t: Tree): Tree = t match {
+        case x if x.tpe.derivesFrom(defn.NothingClass) => t
+        case Typed(x, _) => lookup(x)
+        case Block(_, x) => lookup(x)
+        case _ => null
+      }
+    }
+    def notathing(t: Tree): Boolean = t match {
+      case Notathing(_) => true
+      case _ => false
+    }
     val transformer: Transformer = () => localCtx => {
-      case Apply(Select(qual, _), args)  if qual.tpe.derivesFrom(defn.NothingClass) => qual
-      case Apply(Select(qual, _), args)  if args.exists(x => x.tpe.derivesFrom(defn.NothingClass)) =>
-        val (keep, noth :: other) = args.span(x => !x.tpe.derivesFrom(defn.NothingClass))
-        Block(qual :: keep, noth)
-      case Assign(_, rhs) if rhs.tpe.derivesFrom(defn.NothingClass) =>
+      case t @ Apply(Select(Notathing(qual), _), args) =>
+        Typed(qual, TypeTree(t.tpe))
+      // This case leads to complications with multiple argument lists,
+      // how to do you rewrites tree.witType(???)(ctx).withType(???)(ctx)
+      // using Ycheckable steps?
+
+      // Solution: only transform when having a complete application,
+      // steal code from tailRec
+
+      // case t @ Apply(Select(qual, _), args) if args.exists(notathing) =>
+      //   val (keep, noth :: other) = args.span(x => !notathing(x))
+      //   Block(qual :: keep, Typed(noth, TypeTree(t.tpe)))
+      case Assign(_, rhs) if notathing(rhs) =>
         rhs
-      case If(cond, _, _) if cond.tpe.derivesFrom(defn.NothingClass) => cond
-      case a: Block if a.stats.exists(x => x.tpe.derivesFrom(defn.NothingClass))  =>
-        val (keep, noth :: other) = a.stats.span(x => !x.tpe.derivesFrom(defn.NothingClass))
-        val keep2 = other.filter(x => x.isDef)
-        Block(keep ::: keep2, noth)
+      case t @ If(Notathing(cond), _, _) =>
+        Typed(cond, TypeTree(t.tpe))
+      case b: Block if b.stats.exists(x => !x.isDef && notathing(x)) =>
+        val (keep, noth :: other) = b.stats.span(x => x.isDef || !notathing(x))
+        val keepDefs = other.filter(x => x.isDef)
+        val body = keep ::: keepDefs
+        Typed(Block(body, noth), TypeTree(b.tpe))
       case t => t
     }
-    ("bubbleUpNothing", BeforeAndAfterErasure, NoVisitor, transformer)
+    ("bubbleUpNothing", BeforeErasure, NoVisitor, transformer)
   }
 
   private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
@@ -773,8 +813,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         (t.symbol.isGetter && !t.symbol.is(Flags.Mutable | Flags.Lazy)) ||
         (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
         (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
-          keepOnlySideEffects(rec) // accessing a field of a product
-      case Select(qual, _) if !t.symbol.is(Flags.Mutable | Flags.Lazy) && !t.symbol.is(Flags.Method) =>
+          keepOnlySideEffects(rec) // Accessing a field of a product
+      case s @ Select(qual, name) if
+          !name.eq(nme.TYPE_) && // Keep the .TYPE added by ClassOf
+          !t.symbol.is(Flags.Mutable | Flags.Lazy) && !t.symbol.is(Flags.Method) =>
         keepOnlySideEffects(qual)
       case Block(List(t: DefDef), s: Closure) =>
         EmptyTree
@@ -796,7 +838,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         // invalidates the denotation cache. Because this optimization only
         // operates locally, this should be fine.
         val denot = app.fun.symbol.denot
-        // println(s"replacing ${app.symbol}")
+        simplify.println(s"replacing ${app.symbol}")
         if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
           val newLabelType = app.symbol.info match {
             case mt: MethodType =>
@@ -872,8 +914,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   /** Inlines LabelDef which are used exactly once. */
   val inlineLabelsCalledOnce: Optimization = { implicit ctx: Context =>
-    val timesUsed = collection.mutable.HashMap[Symbol, Int]()
-    val defined = collection.mutable.HashMap[Symbol, DefDef]()
+    val timesUsed = mutable.HashMap[Symbol, Int]()
+    val defined = mutable.HashMap[Symbol, DefDef]()
 
     val visitor: Visitor = {
       case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
@@ -891,7 +933,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         defined.get(a.symbol) match {
           case None => a
           case Some(defDef) if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramInfoss == List(Nil) =>
-            // println(s"Inlining ${defDef.name}")
+            simplify.println(s"Inlining labeldef ${defDef.name}")
             defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
           case Some(defDef) if defDef.rhs.isInstanceOf[Literal] =>
             defDef.rhs
@@ -899,11 +941,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             a
         }
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
-        // println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
+        simplify.println(s"Dropping labeldef (used once) ${a.name} ${timesUsed.get(a.symbol)}")
         defined.put(a.symbol, a)
         EmptyTree
       case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 0 && defined.contains(a.symbol)) =>
-        // println(s"Dropping ${a.name} ${timesUsed.get(a.symbol)}")
+        simplify.println(s"Dropping labeldef (never used) ${a.name} ${timesUsed.get(a.symbol)}")
         EmptyTree
       case t => t
     }
@@ -912,8 +954,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   /** Rewrites pairs of consecutive LabelDef jumps by jumping directly to the target. */
   val jumpjump: Optimization = { implicit ctx: Context =>
-    // optimize label defs that call other label-defs
-    val defined = collection.mutable.HashMap[Symbol, Symbol]()
+    // Optimize label defs that call other label-defs
+    val defined = mutable.HashMap[Symbol, Symbol]()
 
     val visitor: Visitor = {
       case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
@@ -938,7 +980,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             ref(fwd).appliedToArgs(a.args)
         }
       case a: DefDef if defined.contains(a.symbol) =>
-        // println(s"dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
+        simplify.println(s"Dropping ${a.symbol.showFullName} as forwarder to ${defined(a.symbol).showFullName}")
         EmptyTree
       case t => t
     }
@@ -947,8 +989,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   /** Inlines Option methods whose result is known statically. */
   val inlineOptions: Optimization = { implicit ctx: Context =>
-    val somes = collection.mutable.HashMap[Symbol, Tree]()
-    val nones = collection.mutable.HashSet[Symbol]()
+    val somes = mutable.HashMap[Symbol, Tree]()
+    val nones = mutable.HashSet[Symbol]()
 
     val visitor: Visitor = {
       case valdef: ValDef if !valdef.symbol.is(Flags.Mutable) &&
@@ -993,12 +1035,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       if (nw ne old) nw
       else tree
     }
-    ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
+    ("inlineLabelsCalledOnce", BeforeErasure, visitor, transformer)
   }
 
   /** Rewrite vars with exactly one assignment as vals. */
   val valify: Optimization = { implicit ctx: Context =>
-    // either a duplicate or a read through series of immutable fields
+    // Either a duplicate or a read through series of immutable fields.
     val defined: mutable.Map[Symbol, ValDef] = mutable.Map()
     val firstRead: mutable.Map[Symbol, RefTree] = mutable.Map()
     val firstWrite: mutable.Map[Symbol, Assign] = mutable.Map()
@@ -1026,7 +1068,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
     val transformer: Transformer = () => localCtx => {
       val transformation: Tree => Tree = {
-        case t: Block => // drop non-side-effecting stats
+        case t: Block => // Drop non-side-effecting stats
           val valdefs = t.stats.collect {
             case t: ValDef if defined.contains(t.symbol) => t
           }
@@ -1067,23 +1109,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     ("valify", BeforeAndAfterErasure, visitor, transformer)
   }
 
-  /** Gets ride of duplicate parameters of tail recursive functions using mutable parameter.
-   *
-   *  Unlike what's done in scalac, this is limited to the simple cases,
-   *  for instance, we would not optimize anything in the following case:
-   *
-   *  def f(x, y) = f(x + y + 1, x - y - 1)
-   *
-   *  In scalac the above is optimized using a bytecode trick which cannot be
-   *  expressed in source code. In the example above, x can be turned into a var
-   *  by first doing a DUP to push the current value onto the stack. This
-   *  introduces a tight coupling between backend and tqilreq which we prefer
-   *  to avoid in dotty.
-   */
+  /** Inline vals */
   val devalify: Optimization = { implicit ctx: Context =>
-    val timesUsed = collection.mutable.HashMap[Symbol, Int]()
-    val defined = collection.mutable.HashSet[Symbol]()
-    val copies = collection.mutable.HashMap[Symbol, Tree]() // either a duplicate or a read through series of immutable fields
+    val timesUsed = mutable.HashMap[Symbol, Int]()
+    val defined = mutable.HashSet[Symbol]()
+    // Either a duplicate or a read through series of immutable fields
+    val copies = mutable.HashMap[Symbol, Tree]()
     val visitor: Visitor = {
       case valdef: ValDef if !valdef.symbol.is(Flags.Param) &&
                              !valdef.symbol.is(Flags.Mutable | Flags.Module | Flags.Lazy) &&
@@ -1100,7 +1131,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val b4 = timesUsed.getOrElseUpdate(symIfExists, 0)
         timesUsed.put(symIfExists, b4 + 1)
 
-      case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass && !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
+      case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass &&
+                             !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
         // TODO: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 
@@ -1141,13 +1173,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       val transformation: Tree => Tree = {
         case t: ValDef if valsToDrop.contains(t.symbol) =>
-          // println(s"dropping definition of ${t.symbol.showFullName} as not used")
+          // TODO: Could emit a warning for non synthetic code? This valdef is
+          // probably something users would want to remove from source...
+          simplify.println(s"Dropping definition of ${t.symbol.showFullName} as not used")
           t.rhs.changeOwner(t.symbol, t.symbol.owner)
         case t: ValDef if replacements.contains(t.symbol) =>
-          // println(s"dropping definition of ${t.symbol.showFullName} as an alias")
+          simplify.println(s"Dropping definition of ${t.symbol.showFullName} as an alias")
           EmptyTree
-        case t: Block => // drop non-side-effecting stats
-          t
         case t: New =>
           val symIfExists = t.tpt.tpe.normalizedPrefix.termSymbol
           if (replacements.contains(symIfExists)) {
@@ -1168,7 +1200,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       transformation
     }
-    ("devalify", BeforeAndAfterErasure, visitor, transformer)
+    // See tests/pos/devalify.scala for examples of why this needs to be after Erasure.
+    ("devalify", AfterErasure, visitor, transformer)
   }
 
   /** Inline val with exactly one assignment to a var. For example:
@@ -1187,8 +1220,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    *  }
    */
   val varify: Optimization = { implicit ctx: Context =>
-    val paramsTimesUsed = collection.mutable.HashMap[Symbol, Int]()
-    val possibleRenames = collection.mutable.HashMap[Symbol, Set[Symbol]]()
+    val paramsTimesUsed = mutable.HashMap[Symbol, Int]()
+    val possibleRenames = mutable.HashMap[Symbol, Set[Symbol]]()
     val visitor: Visitor = {
       case t: ValDef
         if t.symbol.is(Flags.Param) =>
diff --git a/compiler/test/dotc/tests.scala b/compiler/test/dotc/tests.scala
index ee441d44b4bd..8842840863de 100644
--- a/compiler/test/dotc/tests.scala
+++ b/compiler/test/dotc/tests.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")
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 8af721ca6cb5..18496eada306 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -32,7 +32,7 @@ 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) +
@@ -40,7 +40,7 @@ class CompilationTests extends ParallelTesting {
     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) +
diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
index 968bbf145585..9c756019f7b2 100644
--- a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
+++ b/compiler/test/dotty/tools/vulpix/TestConfiguration.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")
diff --git a/tests/pos/bubbleUpNothing.scala b/tests/pos/bubbleUpNothing.scala
new file mode 100644
index 000000000000..1c4da164866d
--- /dev/null
+++ b/tests/pos/bubbleUpNothing.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(???)
+  }
+}
diff --git a/tests/pos/devalify.scala b/tests/pos/devalify.scala
new file mode 100644
index 000000000000..87e0193dbf47
--- /dev/null
+++ b/tests/pos/devalify.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)
+  }
+}

From 2f2223039a661ffe0480629ee373aaf90d96dd56 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Thu, 11 May 2017 17:35:20 +0200
Subject: [PATCH 60/88] Add missing `.ensureApplied` in `constantFold`

---
 .../src/dotty/tools/dotc/transform/linker/Simplify.scala    | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index f59e4d1aff33..5b790cef7fd7 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -343,11 +343,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case If(cond1, If(cond2, thenp2, elsep2), elsep1) if isSimilar(elsep1, elsep2) =>
         If(cond1.select(defn.Boolean_&&).appliedTo(cond2), thenp2, elsep1)
       case If(cond1, If(cond2, thenp2, elsep2), elsep1) if isSimilar(elsep1, thenp2) =>
-        If(cond1.select(defn.Boolean_!).select(defn.Boolean_||).appliedTo(cond2), elsep1, elsep2)
+        If(cond1.select(defn.Boolean_!).ensureApplied.select(defn.Boolean_||).appliedTo(cond2), elsep1, elsep2)
       case If(cond1, thenp1, If(cond2, thenp2, elsep2)) if isSimilar(thenp1, thenp2) =>
         If(cond1.select(defn.Boolean_||).appliedTo(cond2), thenp1, elsep2)
       case If(cond1, thenp1, If(cond2, thenp2, elsep2)) if isSimilar(thenp1, elsep2) =>
-        If(cond1.select(defn.Boolean_||).appliedTo(cond2.select(defn.Boolean_!)), thenp1, thenp2)
+        If(cond1.select(defn.Boolean_||).appliedTo(cond2.select(defn.Boolean_!).ensureApplied), thenp1, thenp2)
       case If(t: Literal, thenp, elsep) =>
         if (t.const.booleanValue) thenp
         else elsep
@@ -368,7 +368,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       //   //if (thenp.const.booleanValue)
       //     cond.select(defn.Boolean_||).appliedTo(elsep)
       //   //else // thenp is false, this tree is bigger then the original
-      //   //  cond.select(defn.Boolean_!).select(defn.Boolean_&&).appliedTo(elsep)
+      //   //  cond.select(defn.Boolean_!).ensureApplied.select(defn.Boolean_&&).appliedTo(elsep)
       // case ift @ If(cond, thenp, elsep :Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && !elsep.const.booleanValue =>
       //   cond.select(defn.Boolean_&&).appliedTo(elsep)
       //   // the other case ins't handled intentionally. See previous case for explanation

From cad55151f612da31e0219ebc7d31168e41ca2883 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Thu, 11 May 2017 18:09:05 +0200
Subject: [PATCH 61/88] bubbleUpNothing: do we want it? It breaks the last 4
 failing tests

---
 compiler/src/dotty/tools/dotc/Compiler.scala                | 6 +++---
 .../src/dotty/tools/dotc/transform/linker/Simplify.scala    | 4 +++-
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/Compiler.scala b/compiler/src/dotty/tools/dotc/Compiler.scala
index 71e197a8e4e3..7e056431161d 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -88,10 +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 Simplify),            // Perform local optimizations, simplified versions of what linker does.
+           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
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 5b790cef7fd7..cdbc40d453b1 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -150,10 +150,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     dropNoEffects               ::
     // inlineLocalObjects          :: // followCases needs to be fixed, see ./tests/pos/rbtree.scala
     // varify                      :: // varify could stop other transformations from being applied. postponed.
-    bubbleUpNothing             ::
+    // bubbleUpNothing             ::
       // Still need to import the tailRec thing
       // t2429.scala
       // constraining-lub.scala
+      // t8933c.scala
+      // t348plus.scala
     constantFold                ::
     Nil
 

From 520e347832d8979ea87cda8ea3fbc6252b912e46 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Thu, 11 May 2017 17:37:20 +0200
Subject: [PATCH 62/88] Kinda fix toString hack: testPicking w/o -optimise +
 tpd swtich

---
 compiler/src/dotty/tools/dotc/ast/tpd.scala   | 54 ++++++++++---------
 .../tools/vulpix/TestConfiguration.scala      |  5 +-
 2 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 348d667dec53..33fc1a9c8151 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -473,14 +473,16 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
-      // @Dmitry: current implementation in master:
-      // ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
-      val untyped = untpd.cpy.Apply(tree)(fun, args)
-      val typed   = ta.assignType(untyped, fun, args)
-      if (untyped.ne(tree) || tree.tpe.toString != typed.tpe.toString)
-        typed
-      else
-        tree.asInstanceOf[Apply]
+      if (ctx.settings.optimise.value) {
+        val untyped = untpd.cpy.Apply(tree)(fun, args)
+        val typed   = ta.assignType(untyped, fun, args)
+        if (untyped.ne(tree))
+          typed
+        else
+          tree.asInstanceOf[Apply]
+      } else {
+        ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
+      }
     }
       // Note: Reassigning the original type if `fun` and `args` have the same types as before
       // does not work here: The computed type depends on the widened function type, not
@@ -488,14 +490,16 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       // same but its widened type might change.
 
     override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
-      // @Dmitry: current implementation in master:
-      // ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
-      val untyped = untpd.cpy.TypeApply(tree)(fun, args)
-      val typed   = ta.assignType(untyped, fun, args)
-      if (untyped.ne(tree) || tree.tpe.toString != typed.tpe.toString)
-        typed
-      else
-        tree.asInstanceOf[TypeApply]
+      if (ctx.settings.optimise.value) {
+        val untyped = untpd.cpy.TypeApply(tree)(fun, args)
+        val typed   = ta.assignType(untyped, fun, args)
+        if (untyped.ne(tree))
+          typed
+        else
+          tree.asInstanceOf[TypeApply]
+      } else {
+        ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
+      }
     }
       // Same remark as for Apply
 
@@ -531,14 +535,16 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
-      // @Dmitry: current implementation in master:
-      // ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
-      val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
-      val typed   = ta.assignType(untyped, meth, tpt)
-      if (untyped.ne(tree) || tree.tpe.toString != typed.tpe.toString)
-        typed
-      else
-        tree.asInstanceOf[Closure]
+      if (ctx.settings.optimise.value) {
+        val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
+        val typed   = ta.assignType(untyped, meth, tpt)
+        if (untyped.ne(tree))
+          typed
+        else
+          tree.asInstanceOf[Closure]
+      } else {
+        ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
+      }
     }
       // Same remark as for Apply
 
diff --git a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
index 9c756019f7b2..440a0a629534 100644
--- a/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
+++ b/compiler/test/dotty/tools/vulpix/TestConfiguration.scala
@@ -52,10 +52,11 @@ object TestConfiguration {
 
   private val yCheckOptions = Array("-Ycheck:tailrec,resolveSuper,mixin,arrayConstructors,labelDef")
 
-  val defaultOptions = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath :+ "-optimise"
+  val defaultUnoptimised = noCheckOptions ++ checkOptions ++ yCheckOptions ++ classPath
+  val defaultOptions = defaultUnoptimised :+ "-optimise"
   val allowDeepSubtypes = defaultOptions diff Array("-Yno-deep-subtypes")
   val allowDoubleBindings = defaultOptions diff Array("-Yno-double-bindings")
-  val picklingOptions = defaultOptions ++ Array(
+  val picklingOptions = defaultUnoptimised ++ Array(
     "-Xprint-types",
     "-Ytest-pickler",
     "-Yprintpos"

From ecaa6e985c15cf0e55039e21c4181a3a3776185f Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 10:35:19 +0200
Subject: [PATCH 63/88] Reimplement TypeErasure#erasedLub with the documented
 algorithm

This is removing a disparity between lubs obtained before and after erasure.

Consider this example:

```
if b ast.Trees.Match(???)
else ast.Trees.Literal(???)
```

Before erasure this would be an or type that's later widen to
`ast.Trees.TermTree`. Because of `erasedLub` bias for classes, recomputing
this lub after erasure lead to `ast.Trees.Tree` instead.

This disparity prevents a local optimisation from being Ycheckable.
---
 .../dotty/tools/dotc/core/TypeErasure.scala   | 52 ++++++++++++-------
 1 file changed, 33 insertions(+), 19 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
index e3f4205494c8..c87fb9857e8d 100644
--- a/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
+++ b/compiler/src/dotty/tools/dotc/core/TypeErasure.scala
@@ -226,7 +226,8 @@ object TypeErasure {
    *      S is last   : in the linearization of the first argument type `tp1`
    *                    there are no minimal common superclasses or traits that
    *                    come after S.
-   *  (the reason to pick last is that we prefer classes over traits that way).
+   *  The reason to pick last is that we prefer classes over traits that way,
+   *  which leads to more predictable bytecode and (?) faster dynamic dispatch.
    */
   def erasedLub(tp1: Type, tp2: Type)(implicit ctx: Context): Type = tp1 match {
     case JavaArrayType(elem1) =>
@@ -245,25 +246,38 @@ object TypeErasure {
         case JavaArrayType(_) => defn.ObjectType
         case _ =>
           val cls2 = tp2.classSymbol
-          @tailrec def loop(bcs: List[ClassSymbol], bestSoFar: ClassSymbol): ClassSymbol = bcs match {
-            case bc :: bcs1 =>
-              if (cls2.derivesFrom(bc)) {
-                val newBest = if (bestSoFar.derivesFrom(bc)) bestSoFar else bc
-
-                if (!bc.is(Trait) && bc != defn.AnyClass)
-                  newBest
-                else
-                  loop(bcs1, newBest)
-              } else
-                loop(bcs1, bestSoFar)
-            case nil =>
-              bestSoFar
+
+          /** takeWhile+1 */
+          def takeUntil[T](l: List[T])(f: T => Boolean): List[T] = {
+            @tailrec def loop(tail: List[T], acc: List[T]): List[T] =
+              tail match {
+                case h :: t => loop(if (f(h)) t else Nil, h :: acc)
+                case Nil    => acc.reverse
+              }
+            loop(l, Nil)
+          }
+
+          // We are not interested in anything that is not a supertype of tp2
+          val tp2superclasses = tp1.baseClasses.filter(cls2.derivesFrom)
+
+          // From the spec, "Linearization also satisfies the property that a
+          // linearization of a class always contains the linearization of its
+          // direct superclass as a suffix"; it's enought to consider every
+          // candidate up to the first class.
+          val candidates = takeUntil(tp2superclasses)(!_.is(Trait))
+
+          // Candidates st "no other common superclass or trait derives from S"
+          val minimums = candidates.filter { cand =>
+            candidates.forall(x => !x.derivesFrom(cand) || x.eq(cand))
+          }
+
+          // Pick the last minimum to prioritise classes over traits
+          minimums.lastOption match {
+            case Some(lub) if lub != defn.AnyClass && lub != defn.AnyValClass =>
+              lub.typeRef
+            case _ => // Any/AnyVal only exist before erasure
+              defn.ObjectType
           }
-          val t = loop(tp1.baseClasses, defn.ObjectClass)
-          if (t eq defn.AnyValClass)
-            // while AnyVal is a valid common super class for primitives it does not exist after erasure
-            defn.ObjectType
-          else t.typeRef
       }
   }
 

From 3d4cdd7f3c85c34f0b96ce453fce72936ea7ae5a Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 10:39:16 +0200
Subject: [PATCH 64/88] Clean up Simplify

---
 .../tools/dotc/config/CompilerCommand.scala   |   1 -
 .../tools/dotc/core/SymDenotations.scala      |   2 +-
 .../dotc/transform/linker/Simplify.scala      | 168 ++++++++----------
 .../test/dotty/tools/DottyTypeStealer.scala   |   2 +-
 4 files changed, 81 insertions(+), 92 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
index c2301a3aa252..24cfd0f7780a 100644
--- a/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
+++ b/compiler/src/dotty/tools/dotc/config/CompilerCommand.scala
@@ -1,4 +1,3 @@
-
 package dotty.tools.dotc
 package config
 
diff --git a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
index d3865d1e0ce1..bb4ebdcf7bdd 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -467,7 +467,7 @@ object SymDenotations {
       name.toTermName == nme.COMPANION_CLASS_METHOD ||
       name.toTermName == nme.COMPANION_MODULE_METHOD
 
-    /** Is this a syntetic method that represents conversions between representations of a value class
+    /** Is this a synthetic method that represents conversions between representations of a value class
       *  These methods are generated in ExtensionMethods
       *  and used in ElimErasedValueType.
       */
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index cdbc40d453b1..59ff107f1d41 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -40,75 +40,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     this
   }
 
-  private def desugarIdent(i: Ident)(implicit ctx: Context): Option[Select] = {
-    i.tpe match {
-      case TermRef(prefix: TermRef, name) =>
-        Some(ref(prefix).select(i.symbol))
-      case TermRef(prefix: ThisType, name) =>
-        Some(This(prefix.cls).select(i.symbol))
-      case _ => None
-    }
-  }
-
-  private def dropCasts(t: Tree)(implicit ctx: Context): Tree = t match {
-    // case TypeApply(aio@Select(rec, nm), _) if aio.symbol == defn.Any_asInstanceOf => dropCasts(rec)
-    case Typed(t, tpe) => t
-    case _ => t
-  }
-
-  private def readingOnlyVals(t: Tree)(implicit ctx: Context): Boolean = dropCasts(t) match {
-    case Typed(exp, _) => readingOnlyVals(exp)
-    case TypeApply(fun @ Select(rec, _), List(tp)) =>
-      if ((fun.symbol eq defn.Any_asInstanceOf) && rec.tpe.derivesFrom(tp.tpe.classSymbol))
-        readingOnlyVals(rec)
-      else false
-    case Apply(Select(rec, _), Nil) =>
-      def isGetterOfAImmutableField = t.symbol.isGetter && !t.symbol.is(Flags.Mutable)
-      def isCaseClassWithVar        = t.symbol.info.decls.exists(_.is(Flags.Mutable))
-      def isAccessingProductField   = t.symbol.exists                               &&
-                                      t.symbol.owner.derivesFrom(defn.ProductClass) &&
-                                      t.symbol.owner.is(Flags.CaseClass)            &&
-                                      t.symbol.name.isSelectorName                  &&
-                                      !isCaseClassWithVar // Conservative Covers case class A(var x: Int)
-      def isImmutableCaseAccessor   = t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)
-      if (isGetterOfAImmutableField || isAccessingProductField || isImmutableCaseAccessor)
-        readingOnlyVals(rec)
-      else false
-    case Select(rec, _) if t.symbol.is(Flags.Method) =>
-      if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
-      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) {
-        def isImmutableField = {
-          val fieldId = t.symbol.name.toString.drop(1).toInt - 1
-          !t.symbol.owner.caseAccessors(ctx)(fieldId).is(Flags.Mutable)
-        }
-        if (isImmutableField) readingOnlyVals(rec) // accessing a field of a product
-        else false
-      } else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
-        readingOnlyVals(rec)
-      else false
-    case Select(qual, _) if !t.symbol.is(Flags.Mutable) =>
-      readingOnlyVals(qual)
-    case t: Ident if !t.symbol.is(Flags.Mutable) && !t.symbol.is(Flags.Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
-      desugarIdent(t) match {
-        case Some(t) => readingOnlyVals(t)
-        case None => true
-      }
-    case t: This => true
-    // null => false, or the following fails devalify:
-    // trait I {
-    //   def foo: Any = null
-    // }
-    // object Main {
-    //   def main = {
-    //     val s: I = null
-    //     s.foo
-    //   }
-    // }
-    case Literal(Constant(null)) => false
-    case t: Literal => true
-    case _ => false
-  }
-
   type Visitor = Tree => Unit
   type ErasureCompatibility = Int
   val BeforeErasure: ErasureCompatibility = 1
@@ -134,14 +65,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private lazy val _optimizations: Seq[Optimization] =
     inlineCaseIntrinsics        ::
-    removeUnnecessaryNullChecks :: // Doesn't seams to work AfterErasure
+    removeUnnecessaryNullChecks ::
     inlineOptions               ::
-       // Tests that fail when enabled AfterErasure, to be investigated?
-       // ../tests/run/Course-2002-04.scala failed
-       // ../tests/run/t2005.scala failed
-       // ../tests/run/optimizer-array-load.scala failed
-       // ../tests/pos/virtpatmat_exist1.scala failed
-       // ../tests/pos/t1133.scala failed
     inlineLabelsCalledOnce      ::
     valify                      ::
     devalify                    ::
@@ -151,11 +76,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     // inlineLocalObjects          :: // followCases needs to be fixed, see ./tests/pos/rbtree.scala
     // varify                      :: // varify could stop other transformations from being applied. postponed.
     // bubbleUpNothing             ::
-      // Still need to import the tailRec thing
-      // t2429.scala
-      // constraining-lub.scala
-      // t8933c.scala
-      // t348plus.scala
     constantFold                ::
     Nil
 
@@ -170,7 +90,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       while (rhs1 ne rhs0) {
         rhs1 = rhs0
         val initialized = _optimizations.map(x => x(ctx.withOwner(tree.symbol)))
-        var (names, erasureSupport, visitors, transformers) = unzip4(initialized)
+        var (names, erasureSupport , visitors, transformers) = unzip4(initialized)
         // TODO: fuse for performance
         while (names.nonEmpty) {
           val nextVisitor = visitors.head
@@ -202,6 +122,75 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     } else tree
   }
 
+  private def desugarIdent(i: Ident)(implicit ctx: Context): Option[Select] = {
+    i.tpe match {
+      case TermRef(prefix: TermRef, name) =>
+        Some(ref(prefix).select(i.symbol))
+      case TermRef(prefix: ThisType, name) =>
+        Some(This(prefix.cls).select(i.symbol))
+      case _ => None
+    }
+  }
+
+  private def dropCasts(t: Tree)(implicit ctx: Context): Tree = t match {
+    // case TypeApply(aio@Select(rec, nm), _) if aio.symbol == defn.Any_asInstanceOf => dropCasts(rec)
+    case Typed(t, tpe) => t
+    case _ => t
+  }
+
+  private def readingOnlyVals(t: Tree)(implicit ctx: Context): Boolean = dropCasts(t) match {
+    case Typed(exp, _) => readingOnlyVals(exp)
+    case TypeApply(fun @ Select(rec, _), List(tp)) =>
+      if ((fun.symbol eq defn.Any_asInstanceOf) && rec.tpe.derivesFrom(tp.tpe.classSymbol))
+        readingOnlyVals(rec)
+      else false
+    case Apply(Select(rec, _), Nil) =>
+      def isGetterOfAImmutableField = t.symbol.isGetter && !t.symbol.is(Flags.Mutable)
+      def isCaseClassWithVar        = t.symbol.info.decls.exists(_.is(Flags.Mutable))
+      def isAccessingProductField   = t.symbol.exists                               &&
+                                      t.symbol.owner.derivesFrom(defn.ProductClass) &&
+                                      t.symbol.owner.is(Flags.CaseClass)            &&
+                                      t.symbol.name.isSelectorName                  &&
+                                      !isCaseClassWithVar // Conservative Covers case class A(var x: Int)
+      def isImmutableCaseAccessor   = t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)
+      if (isGetterOfAImmutableField || isAccessingProductField || isImmutableCaseAccessor)
+        readingOnlyVals(rec)
+      else false
+    case Select(rec, _) if t.symbol.is(Flags.Method) =>
+      if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) {
+        def isImmutableField = {
+          val fieldId = t.symbol.name.toString.drop(1).toInt - 1
+          !t.symbol.owner.caseAccessors(ctx)(fieldId).is(Flags.Mutable)
+        }
+        if (isImmutableField) readingOnlyVals(rec) // accessing a field of a product
+        else false
+      } else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
+        readingOnlyVals(rec)
+      else false
+    case Select(qual, _) if !t.symbol.is(Flags.Mutable) =>
+      readingOnlyVals(qual)
+    case t: Ident if !t.symbol.is(Flags.Mutable) && !t.symbol.is(Flags.Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
+      desugarIdent(t) match {
+        case Some(t) => readingOnlyVals(t)
+        case None => true
+      }
+    case t: This => true
+    // null => false, or the following fails devalify:
+    // trait I {
+    //   def foo: Any = null
+    // }
+    // object Main {
+    //   def main = {
+    //     val s: I = null
+    //     s.foo
+    //   }
+    // }
+    case Literal(Constant(null)) => false
+    case t: Literal => true
+    case _ => false
+  }
+
   /** Inline case class specific methods using desugarings assumptions.
    *
    * - CC.apply(args)              → new CC(args)
@@ -374,9 +363,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       // case ift @ If(cond, thenp, elsep :Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && !elsep.const.booleanValue =>
       //   cond.select(defn.Boolean_&&).appliedTo(elsep)
       //   // the other case ins't handled intentionally. See previous case for explanation
-      case If(t@ Select(recv, _), thenp, elsep) if t.symbol eq defn.Boolean_! =>
+      case If(t @ Select(recv, _), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         If(recv, elsep, thenp)
-      case If(t@ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
+      case If(t @ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         If(recv, elsep, thenp)
       // TODO: similar trick for comparisons.
       // TODO: handle comparison with min\max values
@@ -384,7 +373,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         rec
       case meth1 @ Select(meth2 @ Select(rec, _), _) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! && !ctx.erasedTypes =>
         rec
-      case t@Apply(Select(lhs, _), List(rhs)) =>
+      case t @ Apply(Select(lhs, _), List(rhs)) =>
         val sym = t.symbol
         (lhs, rhs) match {
           case (lhs, Literal(_)) if !lhs.isInstanceOf[Literal] && symmetricOperations.contains(sym) =>
@@ -441,6 +430,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t if !isPureExpr(t) =>
         t
       case t =>
+        // TODO: did not manage to trigger this in tests
         val s = ConstFold.apply(t)
         if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {
           val constant = s.tpe.asInstanceOf[ConstantType].value
@@ -798,7 +788,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private def keepOnlySideEffects(t: Tree)(implicit ctx: Context): Tree = {
     t match {
-      case t: Literal =>
+      case l: Literal =>
         EmptyTree
       case t: This =>
         EmptyTree
@@ -889,8 +879,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case Block(Nil, expr) => expr
       case a: Block  =>
         val newStats0 = a.stats.mapConserve(keepOnlySideEffects)
-        val newStats1 = if (newStats0 eq a.stats) newStats0 else newStats0.flatMap{
-          case x: Block=> x.stats ::: List(x.expr)
+        val newStats1 = if (newStats0 eq a.stats) newStats0 else newStats0.flatMap {
+          case x: Block => x.stats ::: List(x.expr)
           case EmptyTree => Nil
           case t => t :: Nil
         }
@@ -1037,7 +1027,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       if (nw ne old) nw
       else tree
     }
-    ("inlineLabelsCalledOnce", BeforeErasure, visitor, transformer)
+    ("inlineOptions", BeforeErasure, visitor, transformer)
   }
 
   /** Rewrite vars with exactly one assignment as vals. */
diff --git a/compiler/test/dotty/tools/DottyTypeStealer.scala b/compiler/test/dotty/tools/DottyTypeStealer.scala
index 727cd9e7da19..331fded9b025 100644
--- a/compiler/test/dotty/tools/DottyTypeStealer.scala
+++ b/compiler/test/dotty/tools/DottyTypeStealer.scala
@@ -14,7 +14,7 @@ object DottyTypeStealer extends DottyTest {
     val gatheredSource = s" ${source}\n object A$dummyName {$vals}"
     var scontext : Context = null
     var tp: List[Type] = null
-    checkCompile("frontend",gatheredSource) {
+    checkCompile("frontend", gatheredSource) {
       (tree, context) =>
         implicit val ctx = context
         val findValDef: (List[ValDef], tpd.Tree) => List[ValDef] =

From a2bead928d8b41eebfa8b7009088bf58794f0437 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 10:43:23 +0200
Subject: [PATCH 65/88] Partially fix pickling tests failing with smarter tpd

This also seems to be a reason why Ycheck:front fails.

typeAssigner is REMOVING partial evaluation that typer did
when you copy a tree. It means that types would be different if
you test pickling.

Update made to homogenize:

- Don't print constant types in pickling.
- Sort union types according to their .show String
---
 compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala   | 5 ++++-
 compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala | 2 ++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
index 8aec867921eb..3ba90409e295 100644
--- a/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/PlainPrinter.scala
@@ -53,7 +53,10 @@ class PlainPrinter(_ctx: Context) extends Printer {
         case AndType(tp1, tp2) =>
           homogenize(tp1) & homogenize(tp2)
         case OrType(tp1, tp2) =>
-          homogenize(tp1) | homogenize(tp2)
+          if (tp1.show > tp2.show)
+            homogenize(tp1) | homogenize(tp2)
+          else
+            homogenize(tp2) | homogenize(tp1)
         case tp: SkolemType =>
           homogenize(tp.info)
         case tp: LazyRef =>
diff --git a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
index fcda277012f3..10c6b369c136 100644
--- a/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
+++ b/compiler/src/dotty/tools/dotc/printing/RefinedPrinter.scala
@@ -125,6 +125,8 @@ class RefinedPrinter(_ctx: Context) extends PlainPrinter(_ctx) {
         ("implicit " provided isImplicit) ~ argStr ~ " => " ~ argText(args.last)
       }
     homogenize(tp) match {
+      case x: ConstantType if homogenizedView =>
+        return toText(x.widen)
       case AppliedType(tycon, args) =>
         val cls = tycon.typeSymbol
         if (tycon.isRepeatedParam) return toTextLocal(args.head) ~ "*"

From dec2766c77377c2bd115d44bdf333a58f5528d77 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 10:56:33 +0200
Subject: [PATCH 66/88] Add byte code SimplifyTests

---
 compiler/test/dotty/tools/DottyTest.scala     |  14 ++-
 .../dotty/tools/dotc/CompilationTests.scala   |   4 +-
 .../test/dotty/tools/dotc/SimplifyTests.scala | 113 ++++++++++++++++++
 3 files changed, 124 insertions(+), 7 deletions(-)
 create mode 100644 compiler/test/dotty/tools/dotc/SimplifyTests.scala

diff --git a/compiler/test/dotty/tools/DottyTest.scala b/compiler/test/dotty/tools/DottyTest.scala
index 39ff014c8f71..f3d59fcdf14f 100644
--- a/compiler/test/dotty/tools/DottyTest.scala
+++ b/compiler/test/dotty/tools/DottyTest.scala
@@ -18,12 +18,11 @@ trait DottyTest extends ContextEscapeDetection {
 
   dotc.parsing.Scanners // initialize keywords
 
-  implicit var ctx: Contexts.Context = {
+  implicit var ctx: Context = {
     val base = new ContextBase {}
     import base.settings._
     val ctx = base.initialCtx.fresh
-    ctx.setSetting(ctx.settings.encoding, "UTF8")
-    ctx.setSetting(ctx.settings.classpath, Jars.dottyLib)
+    initializeCtx(ctx)
     // when classpath is changed in ctx, we need to re-initialize to get the
     // correct classpath from PathResolver
     base.initialize()(ctx)
@@ -35,7 +34,12 @@ trait DottyTest extends ContextEscapeDetection {
     ctx = null
   }
 
-  private def compilerWithChecker(phase: String)(assertion:(tpd.Tree, Context) => Unit) = new Compiler {
+  protected def initializeCtx(fc: FreshContext): Unit = {
+    fc.setSetting(fc.settings.encoding, "UTF8")
+    fc.setSetting(fc.settings.classpath, Jars.dottyLib)
+  }
+
+  private def compilerWithChecker(phase: String)(assertion: (tpd.Tree, Context) => Unit) = new Compiler {
     override def phases = {
       val allPhases = super.phases
       val targetPhase = allPhases.flatten.find(p => p.phaseName == phase).get
@@ -58,7 +62,7 @@ trait DottyTest extends ContextEscapeDetection {
     run.compile(source)
   }
 
-  def checkCompile(checkAfterPhase: String, sources:List[String])(assertion:(tpd.Tree, Context) => Unit): Unit = {
+  def checkCompile(checkAfterPhase: String, sources: List[String])(assertion: (tpd.Tree, Context) => Unit): Unit = {
     val c = compilerWithChecker(checkAfterPhase)(assertion)
     c.rootContext(ctx)
     val run = c.newRun
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 18496eada306..8af721ca6cb5 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -32,7 +32,7 @@ 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) +
@@ -40,7 +40,7 @@ class CompilationTests extends ParallelTesting {
     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) +
diff --git a/compiler/test/dotty/tools/dotc/SimplifyTests.scala b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
new file mode 100644
index 000000000000..5441fe26fd50
--- /dev/null
+++ b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
@@ -0,0 +1,113 @@
+package dotty.tools.dotc
+
+import org.junit.Assert._
+import org.junit.Test
+import dotty.tools.backend.jvm._
+import dotty.tools.dotc.config.CompilerCommand
+import dotty.tools.dotc.core.Contexts.FreshContext
+import scala.tools.asm.tree.MethodNode
+
+class SimplifyPosTests extends DottyBytecodeOptimisedTest with SimplifyEquivalences
+class SimplifyNegTests extends DottyBytecodeTest          with SimplifyEquivalences
+
+class DottyBytecodeOptimisedTest extends DottyBytecodeTest {
+  override protected def initializeCtx(c: FreshContext): Unit = {
+    super.initializeCtx(c)
+    val flags = Array("-optimise") // :+ "-Xprint:simplify"
+    val summary = CompilerCommand.distill(flags)(c)
+    c.setSettings(summary.sstate)
+  }
+}
+
+trait SimplifyEquivalences { self: DottyBytecodeTest =>
+  def check(expr1: String, expr2: String, shared: String = ""): Unit = {
+    import ASMConverters._
+    val source =
+      s"""
+      $shared
+      |class A {
+      |  def main(): Unit = {
+            $expr1
+      |  }
+      |}
+      |class B {
+      |  def main(): Unit = {
+            $expr2
+      |  }
+      |}
+      """.stripMargin
+    checkBCode(source) { dir =>
+      def instructions(clazz: String): List[Instruction] = {
+        val clsIn   = dir.lookupName(s"$clazz.class", directory = false).input
+        val clsNode = loadClassNode(clsIn)
+        instructionsFromMethod(getMethod(clsNode, "main"))
+      }
+      val A = instructions("A")
+      val B = instructions("B")
+      val diff = diffInstructions(A, B)
+      if (this.isInstanceOf[DottyBytecodeOptimisedTest])
+        assert(A == B, s"Bytecode wasn't same:\n$diff")
+      else
+        assert(A != B, s"Bytecode was the same:\n$diff")
+    }
+  }
+
+  @Test def inlineVals =
+    check("println(1)",
+       """
+          |val one = 1
+          |val anotherone = one
+          |println(anotherone)
+       """)
+
+  @Test def inlineCaseIntrinsicsDottyApply =
+    check(
+      expr1  = "CC.apply(1, 2)",
+      expr2  = "new CC(1, 2)",
+      shared = "case class CC(i: Int, j: Int)")
+
+  @Test def inlineCaseIntrinsicsScalacApply =
+    check("::.apply(1, Nil)", "new ::(1, Nil)")
+
+  @Test def inlineCaseIntrinsicsScalacUnapply =
+    check(
+      """
+         |val t = Tuple2(1, "s")
+         |print(Tuple2.unapply(t))
+      """,
+      """
+         |val t = Tuple2(1, "s")
+         |print(new Some(new Tuple2(t._1, t._2)))
+      """)
+
+  @Test def constantFold =
+    check(
+      """
+         |val t = true // val needed, or typer takes care of this
+         |if (t) print(1)
+         |else   print(2)
+      """,
+      """
+         |print(1)
+      """)
+
+  @Test def dropNoEffects =
+    check(
+      """
+         |"wow"
+         |print(1)
+      """,
+      """
+         |print(1)
+      """)
+
+  // @Test def inlineOptions =
+  //   check(
+  //     """
+  //        |val sum = Some("s")
+  //        |println(sum.isDefined)
+  //     """,
+  //     """
+  //        |println(true)
+  //     """)
+}

From a2465b11fb5f86356cdacdce84f8a518781f2db8 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 11:12:17 +0200
Subject: [PATCH 67/88] Refactor the temporary tpd fix

---
 compiler/src/dotty/tools/dotc/ast/tpd.scala | 48 ++++++++-------------
 1 file changed, 17 insertions(+), 31 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 33fc1a9c8151..d1a9555a362c 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -473,33 +473,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
-      if (ctx.settings.optimise.value) {
-        val untyped = untpd.cpy.Apply(tree)(fun, args)
-        val typed   = ta.assignType(untyped, fun, args)
-        if (untyped.ne(tree))
-          typed
-        else
-          tree.asInstanceOf[Apply]
-      } else {
-        ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
-      }
+      val untyped = untpd.cpy.Apply(tree)(fun, args)
+      if (untyped.ne(tree) || !ctx.settings.optimise.value)
+        ta.assignType(untyped, fun, args)
+      else
+        tree.asInstanceOf[Apply]
     }
+
       // Note: Reassigning the original type if `fun` and `args` have the same types as before
       // does not work here: The computed type depends on the widened function type, not
       // the function type itself. A treetransform may keep the function type the
       // same but its widened type might change.
 
     override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
-      if (ctx.settings.optimise.value) {
-        val untyped = untpd.cpy.TypeApply(tree)(fun, args)
-        val typed   = ta.assignType(untyped, fun, args)
-        if (untyped.ne(tree))
-          typed
-        else
-          tree.asInstanceOf[TypeApply]
-      } else {
-        ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
-      }
+      val untyped = untpd.cpy.TypeApply(tree)(fun, args)
+      if (untyped.ne(tree) || !ctx.settings.optimise.value)
+        ta.assignType(untyped, fun, args)
+      else
+        tree.asInstanceOf[TypeApply]
     }
       // Same remark as for Apply
 
@@ -535,16 +526,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
-      if (ctx.settings.optimise.value) {
-        val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
-        val typed   = ta.assignType(untyped, meth, tpt)
-        if (untyped.ne(tree))
-          typed
-        else
-          tree.asInstanceOf[Closure]
-      } else {
-        ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
-      }
+      val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
+      val typed = ta.assignType(untyped, meth, tpt)
+      if (untyped.ne(tree) || !ctx.settings.optimise.value)
+        typed
+      else
+        tree.asInstanceOf[Closure]
     }
       // Same remark as for Apply
 
@@ -980,4 +967,3 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     if (file != null && file.exists) new SourceFile(file, Codec(encoding)) else NoSource
   }
 }
-

From bb0e5b2455f240526de79fe3f4de364702bb12d7 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 11:18:32 +0200
Subject: [PATCH 68/88] Import Flags._

---
 .../dotc/transform/linker/Simplify.scala      | 139 +++++++++---------
 1 file changed, 70 insertions(+), 69 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 59ff107f1d41..bf203a8e98b8 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -17,6 +17,7 @@ import transform.SymUtils._
 import transform.TreeTransforms.{MiniPhaseTransform, TransformerInfo, TreeTransform}
 import typer.ConstFold
 import dotty.tools.dotc.config.Printers.simplify
+import Flags._
 
 /** This phase consists of a series of small, simple, local optimizations
  *  applied as a fix point transformation over Dotty Trees.
@@ -81,7 +82,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val ctx0 = ctx
-    if (optimize && !tree.symbol.is(Flags.Label)) {
+    if (optimize && !tree.symbol.is(Label)) {
       implicit val ctx: Context = ctx0.withOwner(tree.symbol(ctx0))
       // TODO: optimize class bodies before erasure?
       var rhs0 = tree.rhs
@@ -145,32 +146,32 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         readingOnlyVals(rec)
       else false
     case Apply(Select(rec, _), Nil) =>
-      def isGetterOfAImmutableField = t.symbol.isGetter && !t.symbol.is(Flags.Mutable)
-      def isCaseClassWithVar        = t.symbol.info.decls.exists(_.is(Flags.Mutable))
+      def isGetterOfAImmutableField = t.symbol.isGetter && !t.symbol.is(Mutable)
+      def isCaseClassWithVar        = t.symbol.info.decls.exists(_.is(Mutable))
       def isAccessingProductField   = t.symbol.exists                               &&
                                       t.symbol.owner.derivesFrom(defn.ProductClass) &&
-                                      t.symbol.owner.is(Flags.CaseClass)            &&
+                                      t.symbol.owner.is(CaseClass)                  &&
                                       t.symbol.name.isSelectorName                  &&
                                       !isCaseClassWithVar // Conservative Covers case class A(var x: Int)
-      def isImmutableCaseAccessor   = t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)
+      def isImmutableCaseAccessor   = t.symbol.is(CaseAccessor) && !t.symbol.is(Mutable)
       if (isGetterOfAImmutableField || isAccessingProductField || isImmutableCaseAccessor)
         readingOnlyVals(rec)
       else false
-    case Select(rec, _) if t.symbol.is(Flags.Method) =>
-      if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) readingOnlyVals(rec) // getter of a immutable field
-      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) {
+    case Select(rec, _) if t.symbol.is(Method) =>
+      if (t.symbol.isGetter && !t.symbol.is(Mutable)) readingOnlyVals(rec) // getter of a immutable field
+      else if (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(CaseClass) && t.symbol.name.isSelectorName) {
         def isImmutableField = {
           val fieldId = t.symbol.name.toString.drop(1).toInt - 1
-          !t.symbol.owner.caseAccessors(ctx)(fieldId).is(Flags.Mutable)
+          !t.symbol.owner.caseAccessors(ctx)(fieldId).is(Mutable)
         }
         if (isImmutableField) readingOnlyVals(rec) // accessing a field of a product
         else false
-      } else if (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable))
+      } else if (t.symbol.is(CaseAccessor) && !t.symbol.is(Mutable))
         readingOnlyVals(rec)
       else false
-    case Select(qual, _) if !t.symbol.is(Flags.Mutable) =>
+    case Select(qual, _) if !t.symbol.is(Mutable) =>
       readingOnlyVals(qual)
-    case t: Ident if !t.symbol.is(Flags.Mutable) && !t.symbol.is(Flags.Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
+    case t: Ident if !t.symbol.is(Mutable) && !t.symbol.is(Method) && !t.symbol.info.dealias.isInstanceOf[ExprType] =>
       desugarIdent(t) match {
         case Some(t) => readingOnlyVals(t)
         case None => true
@@ -204,13 +205,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    */
   val inlineCaseIntrinsics: Optimization = { implicit ctx: Context =>
     val transformer: Transformer = () => localCtx => {
-      case a: Apply if !a.tpe.isInstanceOf[MethodicType]                 &&
-                       a.symbol.is(Flags.Synthetic)                      &&
-                       a.symbol.owner.is(Flags.Module)                   &&
-                       (a.symbol.name == nme.apply)                      &&
-                       a.symbol.owner.companionClass.is(Flags.CaseClass) &&
-                       !a.tpe.derivesFrom(defn.EnumClass)                &&
-                       isPureExpr(a.tree) =>
+      case a: Apply if !a.tpe.isInstanceOf[MethodicType]                &&
+                       a.symbol.is(Synthetic)                           &&
+                       a.symbol.owner.is(Module)                        &&
+                       (a.symbol.name == nme.apply)                     &&
+                       a.symbol.owner.companionClass.is(CaseClass)      &&
+                       !a.tpe.derivesFrom(defn.EnumClass)               &&
+                       (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
         def unrollArgs(t: Tree, l: List[List[Tree]]): List[List[Tree]] = t match {
           case Apply(t, args) => unrollArgs(t, args :: l)
           case _ => l
@@ -223,13 +224,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val constructor = a.symbol.owner.companionClass.primaryConstructor.asTerm
         rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head))
 
-      case a: Apply if a.symbol.is(Flags.Synthetic)                      &&
-                       a.symbol.owner.is(Flags.Module)                   &&
+      case a: Apply if a.symbol.is(Synthetic)                            &&
+                       a.symbol.owner.is(Module)                         &&
                        (a.symbol.name == nme.unapply)                    &&
-                       a.symbol.owner.companionClass.is(Flags.CaseClass) &&
+                       a.symbol.owner.companionClass.is(CaseClass)       &&
                        !a.tpe.derivesFrom(defn.EnumClass)                &&
-                       isPureExpr(a.tree) =>
-        if (!a.symbol.owner.is(Flags.Scala2x)) {
+                       (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
+        if (!a.symbol.owner.is(Scala2x)) {
           if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
           else a.args.head
         }
@@ -264,7 +265,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
 
         val recv = reciever(a)
-        if (recv.typeSymbol.is(Flags.Module))
+        if (recv.typeSymbol.is(Module))
           New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
         else a
       case t => t
@@ -457,7 +458,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case If(_, thenp, elsep) => followTailPerfect(thenp, symbol); followTailPerfect(elsep, symbol);
         case Apply(fun, _) if fun.symbol.isConstructor && t.tpe.widenDealias == symbol.info.widenDealias.finalResultType.widenDealias =>
           hasPerfectRHS(symbol) = true
-        case Apply(fun, _) if fun.symbol.is(Flags.Label) && (fun.symbol ne symbol) =>
+        case Apply(fun, _) if fun.symbol.is(Label) && (fun.symbol ne symbol) =>
           checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + fun.symbol)
           // assert(forwarderWritesTo.getOrElse(t.symbol, symbol) == symbol)
           forwarderWritesTo(t.symbol) = symbol
@@ -467,15 +468,15 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
     }
     val visitor: Visitor = {
-      case vdef: ValDef if (vdef.symbol.info.classSymbol is Flags.CaseClass) && !vdef.symbol.is(Flags.Lazy)  && !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Flags.Mutable)) =>
+      case vdef: ValDef if (vdef.symbol.info.classSymbol is CaseClass) && !vdef.symbol.is(Lazy)  && !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Mutable)) =>
         followTailPerfect(vdef.rhs, vdef.symbol)
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
         checkGood.put(lhs.symbol, checkGood.getOrElse(lhs.symbol, Set.empty) + rhs.symbol)
-      case t @ Select(qual, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-        (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.maybeOwner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
-        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
+      case t @ Select(qual, _) if (t.symbol.isGetter && !t.symbol.is(Mutable)) ||
+        (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.maybeOwner.is(CaseClass) && t.symbol.name.isSelectorName) ||
+        (t.symbol.is(CaseAccessor) && !t.symbol.is(Mutable)) =>
         gettersCalled(qual.symbol) = true
-      case t: DefDef if t.symbol.is(Flags.Label) =>
+      case t: DefDef if t.symbol.is(Label) =>
         followTailPerfect(t.rhs, t.symbol)
       case _ =>
     }
@@ -494,7 +495,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
 
       val newMappings: Map[Symbol, Map[Symbol, Symbol]] =
-        hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Flags.Method) && !x.is(Flags.Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is Flags.CaseClass))
+        hasPerfectRHS.iterator.map(x => x._1).filter(x => !x.is(Method) && !x.is(Label) && gettersCalled.contains(x.symbol) && (x.symbol.info.classSymbol is CaseClass))
           .map { refVal =>
             simplify.println(s"replacing ${refVal.symbol.fullName} with stack-allocated fields")
             var accessors = refVal.info.classSymbol.caseAccessors.filter(_.isGetter) // TODO: drop mutable ones
@@ -503,7 +504,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val newLocals = accessors.map(x =>
               // TODO: it would be nice to have an additional optimization that
               // TODO: is capable of turning those mutable ones into immutable in common cases
-              ctx.newSymbol(ctx.owner.enclosingMethod, (refVal.name + "$" + x.name).toTermName, Flags.Synthetic | Flags.Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
+              ctx.newSymbol(ctx.owner.enclosingMethod, (refVal.name + "$" + x.name).toTermName, Synthetic | Mutable, x.asSeenFrom(refVal.info).info.finalResultType.widenDealias)
             )
             val fieldMapping = accessors zip newLocals
             val productMappings = productAccessors zip newLocals
@@ -522,7 +523,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             val assigns = (accessors zip args) map (x => ref(fieldsByAccessors(x._1)).becomes(x._2))
             val recreate = sel.appliedToArgs(accessors.map(x => ref(fieldsByAccessors(x))))
             Block(assigns, recreate)
-          case Apply(fun, _) if fun.symbol.is(Flags.Label) =>
+          case Apply(fun, _) if fun.symbol.is(Label) =>
             t // Do nothing. It will do on its own.
           case t: Ident if !t.symbol.owner.isClass && newMappings.contains(t.symbol) && t.symbol.info.classSymbol == target.info.classSymbol =>
             val fieldsByAccessorslhs = newMappings(target)
@@ -545,7 +546,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
       }
 
-      def followCases(t: Symbol, limit: Int = 0): Symbol = if (t.symbol.is(Flags.Label)) {
+      def followCases(t: Symbol, limit: Int = 0): Symbol = if (t.symbol.is(Label)) {
         // TODO: this can create cycles, see ./tests/pos/rbtree.scala
         if (limit > 100 && limit > forwarderWritesTo.size + 1) NoSymbol
           // There may be cycles in labels, that never in the end write to a valdef(the value is always on stack)
@@ -559,7 +560,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       gettersCalled.clear()
 
       val res: Context => Tree => Tree = {localCtx => (t: Tree) => t match {
-        case ddef: DefDef if ddef.symbol.is(Flags.Label) =>
+        case ddef: DefDef if ddef.symbol.is(Label) =>
           newMappings.get(followCases(ddef.symbol)) match {
             case Some(mappings) =>
               cpy.DefDef(ddef)(rhs = splitWrites(ddef.rhs, followCases(ddef.symbol)))
@@ -576,12 +577,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           newMappings.get(ass.lhs.symbol) match {
             case None =>   ass
             case Some(mapping) =>
-              val updates = mapping.filter(x => x._1.is(Flags.CaseAccessor)).map(x => ref(x._2).becomes(ref(ass.lhs.symbol).select(x._1))).toList
+              val updates = mapping.filter(x => x._1.is(CaseAccessor)).map(x => ref(x._2).becomes(ref(ass.lhs.symbol).select(x._1))).toList
               Thicket(ass :: updates)
           }
-        case sel @ Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Flags.Mutable)) ||
-          (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
-          (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
+        case sel @ Select(rec, _) if (t.symbol.isGetter && !t.symbol.is(Mutable)) ||
+          (t.symbol.maybeOwner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(CaseClass) && t.symbol.name.isSelectorName) ||
+          (t.symbol.is(CaseAccessor) && !t.symbol.is(Mutable)) =>
           newMappings.getOrElse(rec.symbol, Map.empty).get(sel.symbol) match {
             case None => t
             case Some(newSym) => ref(newSym)
@@ -600,7 +601,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
         case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
         case TypeApply(fun @ Select(x, _), List(tp)) if fun.symbol eq defn.Any_isInstanceOf =>
-          if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
+          if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Method|Mutable))
             (x.symbol, tp.tpe) :: Nil
           else Nil
         case _ => List.empty
@@ -614,7 +615,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case Apply(x, _) if (x.symbol == defn.Boolean_! || x.symbol == defn.Boolean_||) => List.empty
         case Apply(fun @ Select(x, _), y) if (fun.symbol == defn.Boolean_&&) => recur(x) ++ recur(y.head)
         case Apply(fun @ Select(x, _), List(tp)) if fun.symbol eq defn.Object_ne =>
-          if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Flags.Method|Flags.Mutable))
+          if (x.symbol.exists && !x.symbol.owner.isClass && !x.symbol.is(Method|Mutable))
             x.symbol :: Nil
           else Nil
         case _ => List.empty
@@ -692,7 +693,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case vd: ValDef =>
         val rhs = vd.rhs
         val rhsName = rhs.symbol.name
-        if (!vd.symbol.is(Flags.Mutable) && !rhs.isEmpty) {
+        if (!vd.symbol.is(Mutable) && !rhs.isEmpty) {
           def checkNonNull(t: Tree, target: Symbol): Boolean = t match {
             case Block(_ , expr) => checkNonNull(expr, target)
             case If(_, thenp, elsep) => checkNonNull(thenp, target) && checkNonNull(elsep, target)
@@ -802,9 +803,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else unitLiteral),
           elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else unitLiteral))
       case Select(rec, _) if
-        (t.symbol.isGetter && !t.symbol.is(Flags.Mutable | Flags.Lazy)) ||
-        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(Flags.CaseClass) && t.symbol.name.isSelectorName) ||
-        (t.symbol.is(Flags.CaseAccessor) && !t.symbol.is(Flags.Mutable)) =>
+        (t.symbol.isGetter && !t.symbol.is(Mutable | Lazy)) ||
+        (t.symbol.owner.derivesFrom(defn.ProductClass) && t.symbol.owner.is(CaseClass) && t.symbol.name.isSelectorName) ||
+        (t.symbol.is(CaseAccessor) && !t.symbol.is(Mutable)) =>
           keepOnlySideEffects(rec) // Accessing a field of a product
       case s @ Select(qual, name) if
           !name.eq(nme.TYPE_) && // Keep the .TYPE added by ClassOf
@@ -820,12 +821,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
         cpy.Block(bl)(stats2, expr2)
-      case t: Ident if !t.symbol.is(Flags.Method | Flags.Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
+      case t: Ident if !t.symbol.is(Method | Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
         desugarIdent(t) match {
           case Some(t) => t
           case None => EmptyTree
         }
-      case app: Apply if app.fun.symbol.is(Flags.Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
+      case app: Apply if app.fun.symbol.is(Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
         // This is "the scary hack". It changes the return type to Unit, then
         // invalidates the denotation cache. Because this optimization only
         // operates locally, this should be fine.
@@ -910,11 +911,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val defined = mutable.HashMap[Symbol, DefDef]()
 
     val visitor: Visitor = {
-      case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
+      case defdef: DefDef if defdef.symbol.is(Label)  =>
         var isRecursive = false
         defdef.rhs.foreachSubTree(x => if (x.symbol == defdef.symbol) isRecursive = true)
         if (!isRecursive) defined.put(defdef.symbol, defdef)
-      case t: Apply if t.symbol.is(Flags.Label) =>
+      case t: Apply if t.symbol.is(Label) =>
         val b4 = timesUsed.getOrElseUpdate(t.symbol, 0)
         timesUsed.put(t.symbol, b4 + 1)
       case _ =>
@@ -924,7 +925,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case a: Apply =>
         defined.get(a.symbol) match {
           case None => a
-          case Some(defDef) if a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramInfoss == List(Nil) =>
+          case Some(defDef) if a.symbol.is(Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && a.symbol.info.paramInfoss == List(Nil) =>
             simplify.println(s"Inlining labeldef ${defDef.name}")
             defDef.rhs.changeOwner(defDef.symbol, localCtx.owner)
           case Some(defDef) if defDef.rhs.isInstanceOf[Literal] =>
@@ -932,11 +933,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case Some(_) =>
             a
         }
-      case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
+      case a: DefDef if (a.symbol.is(Label) && timesUsed.getOrElse(a.symbol, 0) == 1 && defined.contains(a.symbol)) =>
         simplify.println(s"Dropping labeldef (used once) ${a.name} ${timesUsed.get(a.symbol)}")
         defined.put(a.symbol, a)
         EmptyTree
-      case a: DefDef if (a.symbol.is(Flags.Label) && timesUsed.getOrElse(a.symbol, 0) == 0 && defined.contains(a.symbol)) =>
+      case a: DefDef if (a.symbol.is(Label) && timesUsed.getOrElse(a.symbol, 0) == 0 && defined.contains(a.symbol)) =>
         simplify.println(s"Dropping labeldef (never used) ${a.name} ${timesUsed.get(a.symbol)}")
         EmptyTree
       case t => t
@@ -950,9 +951,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val defined = mutable.HashMap[Symbol, Symbol]()
 
     val visitor: Visitor = {
-      case defdef: DefDef if defdef.symbol.is(Flags.Label)  =>
+      case defdef: DefDef if defdef.symbol.is(Label)  =>
         defdef.rhs match {
-          case Apply(t, args) if t.symbol.is(Flags.Label) &&
+          case Apply(t, args) if t.symbol.is(Label) &&
             TypeErasure.erasure(defdef.symbol.info.finalResultType).classSymbol ==
             TypeErasure.erasure(t.symbol.info.finalResultType).classSymbol             &&
             args.size == defdef.vparamss.map(_.size).sum                               &&
@@ -985,13 +986,13 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val nones = mutable.HashSet[Symbol]()
 
     val visitor: Visitor = {
-      case valdef: ValDef if !valdef.symbol.is(Flags.Mutable) &&
+      case valdef: ValDef if !valdef.symbol.is(Mutable) &&
         valdef.rhs.isInstanceOf[Apply] && valdef.rhs.tpe.derivesFrom(defn.SomeClass) &&
         valdef.rhs.symbol.isPrimaryConstructor =>
         val Apply(_, value) = valdef.rhs
         somes(valdef.symbol) = value.head
 
-      case valdef: ValDef if !valdef.symbol.is(Flags.Mutable) &&
+      case valdef: ValDef if !valdef.symbol.is(Mutable) &&
         valdef.rhs.isInstanceOf[Apply] && valdef.rhs.tpe.derivesFrom(defn.NoneClass)  =>
         nones += valdef.symbol
       case _ =>
@@ -1038,12 +1039,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val firstWrite: mutable.Map[Symbol, Assign] = mutable.Map()
     val secondWrite: mutable.Map[Symbol, Assign] = mutable.Map()
     val visitor: Visitor = {
-      case t: ValDef if t.symbol.is(Flags.Mutable, Flags.Lazy) && !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
+      case t: ValDef if t.symbol.is(Mutable, Lazy) && !t.symbol.is(Method) && !t.symbol.owner.isClass =>
         if (isPureExpr(t.rhs))
           defined(t.symbol) = t
-      case t: RefTree if t.symbol.exists && !t.symbol.is(Flags.Method) && !t.symbol.owner.isClass =>
+      case t: RefTree if t.symbol.exists && !t.symbol.is(Method) && !t.symbol.owner.isClass =>
         if (!firstWrite.contains(t.symbol)) firstRead(t.symbol) = t
-      case t @ Assign(l, expr) if  !l.symbol.is(Flags.Method) && !l.symbol.owner.isClass =>
+      case t @ Assign(l, expr) if  !l.symbol.is(Method) && !l.symbol.owner.isClass =>
         if (!firstRead.contains(l.symbol)) {
           if (firstWrite.contains(l.symbol)) {
             if (!secondWrite.contains(l.symbol))
@@ -1083,7 +1084,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             case x: ValDef if valsToDrop.contains(x) => EmptyTree
             case t: Assign => assignsToReplace.get(t) match {
               case Some(vd) =>
-                val newD = vd.symbol.asSymDenotation.copySymDenotation(initFlags = vd.symbol.flags.&~(Flags.Mutable))
+                val newD = vd.symbol.asSymDenotation.copySymDenotation(initFlags = vd.symbol.flags.&~(Mutable))
                 newD.installAfter(this)
                 ValDef(vd.symbol.asTerm, t.rhs)
               case None => t
@@ -1108,8 +1109,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     // Either a duplicate or a read through series of immutable fields
     val copies = mutable.HashMap[Symbol, Tree]()
     val visitor: Visitor = {
-      case valdef: ValDef if !valdef.symbol.is(Flags.Param) &&
-                             !valdef.symbol.is(Flags.Mutable | Flags.Module | Flags.Lazy) &&
+      case valdef: ValDef if !valdef.symbol.is(Param) &&
+                             !valdef.symbol.is(Mutable | Module | Lazy) &&
                              valdef.symbol.exists && !valdef.symbol.owner.isClass =>
         defined += valdef.symbol
 
@@ -1124,7 +1125,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         timesUsed.put(symIfExists, b4 + 1)
 
       case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass &&
-                             !valdef.symbol.is(Flags.Param | Flags.Module | Flags.Lazy) =>
+                             !valdef.symbol.is(Param | Module | Lazy) =>
         // TODO: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 
@@ -1138,7 +1139,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       val valsToDrop = defined -- timesUsed.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
         val rhs = dropCasts(x._2)
-        rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Flags.Method) && !rhs.symbol.is(Flags.Mutable))
+        rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Method) && !rhs.symbol.is(Mutable))
       }
       // TODO: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 
@@ -1183,7 +1184,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             New(newTpt)
           }
           else t
-        case t: RefTree if !t.symbol.is(Flags.Method) && !t.symbol.is(Flags.Param) && !t.symbol.is(Flags.Mutable) =>
+        case t: RefTree if !t.symbol.is(Method) && !t.symbol.is(Param) && !t.symbol.is(Mutable) =>
           if (replacements.contains(t.symbol))
             deepReplacer.transform(replacements(t.symbol)).ensureConforms(t.tpe.widen)
           else t
@@ -1216,10 +1217,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     val possibleRenames = mutable.HashMap[Symbol, Set[Symbol]]()
     val visitor: Visitor = {
       case t: ValDef
-        if t.symbol.is(Flags.Param) =>
+        if t.symbol.is(Param) =>
         paramsTimesUsed += (t.symbol -> 0)
       case valDef: ValDef
-        if valDef.symbol.is(Flags.Mutable) =>
+        if valDef.symbol.is(Mutable) =>
         valDef.rhs.foreachSubTree { subtree =>
           if (paramsTimesUsed.contains(subtree.symbol) &&
             valDef.symbol.info.widenDealias <:< subtree.symbol.info.widenDealias) {
@@ -1252,7 +1253,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           else ref(replaced).becomes(t.rhs)
         case t: ValDef
           if paramCandidates.contains(t.symbol) =>
-          t.symbol.flags = Flags.Mutable
+          t.symbol.flags = Mutable
           t
         case t => t
       }

From 92ffff7dabc8fbf6c7dc1cf4850ad420c2a54b1d Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 11:19:12 +0200
Subject: [PATCH 69/88] Add null check and evalOnce to inlineCaseIntrinsics

---
 .../dotc/transform/linker/Simplify.scala      | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index bf203a8e98b8..ddbb4de46c57 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -235,18 +235,21 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           else a.args.head
         }
         else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
-          // TODO: if args is an expression, this will evaluate it multiple times
-          // TODO: if the static type is right, it does not mean it's not null
-          val accessors = a.args.head.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Flags.Method))
-          val fields = accessors.map(x => a.args.head.select(x).ensureApplied)
-          val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
-
-          if (fields.tail.nonEmpty) {
-            val tplAlloc = New(tplType, fields)
-            New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
-          } else { // scalac does not have Tuple1
-            New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), fields.head :: Nil)
+          def some(e: Tree) = {
+            val accessors = e.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Method))
+            val fields = accessors.map(x => e.select(x).ensureApplied)
+            val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
+            if (fields.tail.nonEmpty) {
+              val tplAlloc = New(tplType, fields)
+              New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
+            } else { // scalac does not have Tuple1
+              New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), fields.head :: Nil)
+            }
           }
+          val none = ref(defn.NoneModuleRef)
+          def isNull(e: Tree) = e.select(defn.Object_eq).appliedTo(Literal(Constant(null)))
+          def fi(e: Tree) = If(isNull(e), none, some(e))
+          evalOnce(a.args.head)(fi)
         }
         else a
       case a: Apply if (a.symbol.name == nme.unapplySeq)           &&

From 0e8cbae857adc2883fdaddd45376aa9c19f8f362 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 11:19:50 +0200
Subject: [PATCH 70/88] Don't run problematic optimisations AfterErasure

---
 .../tools/dotc/transform/linker/Simplify.scala     | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index ddbb4de46c57..1e5551f35253 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -273,7 +273,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         else a
       case t => t
     }
-    ("inlineCaseIntrinsics", BeforeAndAfterErasure, NoVisitor, transformer)
+    // To run this optimisation after erasure one would need to specialize it
+    // for constructor with outer pointer and values classes. There is probably
+    // no need to run this more than once.
+    ("inlineCaseIntrinsics", BeforeErasure, NoVisitor, transformer)
   }
 
   /** Various constant folding.
@@ -811,8 +814,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         (t.symbol.is(CaseAccessor) && !t.symbol.is(Mutable)) =>
           keepOnlySideEffects(rec) // Accessing a field of a product
       case s @ Select(qual, name) if
-          !name.eq(nme.TYPE_) && // Keep the .TYPE added by ClassOf
-          !t.symbol.is(Flags.Mutable | Flags.Lazy) && !t.symbol.is(Flags.Method) =>
+          // !name.eq(nme.TYPE_) && // Keep the .TYPE added by ClassOf, would be needed for AfterErasure
+          !t.symbol.is(Mutable | Lazy) && !t.symbol.is(Method) =>
         keepOnlySideEffects(qual)
       case Block(List(t: DefDef), s: Closure) =>
         EmptyTree
@@ -905,7 +908,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         } else a
       case t => t
     }
-    ("dropNoEffects", BeforeAndAfterErasure, NoVisitor, transformer)
+    // BoxedUnit messes up this phase after erasure
+    ("dropNoEffects", BeforeErasure, NoVisitor, transformer)
   }
 
   /** Inlines LabelDef which are used exactly once. */
@@ -945,7 +949,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         EmptyTree
       case t => t
     }
-    ("inlineLabelsCalledOnce", BeforeAndAfterErasure, visitor, transformer)
+    ("inlineLabelsCalledOnce", BeforeErasure, visitor, transformer)
   }
 
   /** Rewrites pairs of consecutive LabelDef jumps by jumping directly to the target. */

From c516fb32f12d00529684c786e022eaa1e31620ce Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 11:21:13 +0200
Subject: [PATCH 71/88] Move to pending t7126.scala (could also be run without
 -optimise)

This is the issue discussed on #2439. The fix implemented there (6f3aa3c0) breaks a bunch of other tests; to be further investigated.
---
 tests/{pos => pending}/t7126.scala | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename tests/{pos => pending}/t7126.scala (100%)

diff --git a/tests/pos/t7126.scala b/tests/pending/t7126.scala
similarity index 100%
rename from tests/pos/t7126.scala
rename to tests/pending/t7126.scala

From 123a02d1adf0db8b8b826a68ad807ac52fea9a42 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 22 May 2017 13:22:17 +0200
Subject: [PATCH 72/88] Isolate the two failing tests in run-not-optimised

---
 .../dotty/tools/dotc/CompilationTests.scala   |  4 +++
 tests/pending/t7126.scala                     | 11 -------
 tests/{run => run-not-optimised}/t4859.check  |  0
 tests/run-not-optimised/t4859.scala           | 29 +++++++++++++++++++
 tests/run-not-optimised/t7126.scala           | 20 +++++++++++++
 tests/run/t4859.scala                         |  2 ++
 6 files changed, 55 insertions(+), 11 deletions(-)
 delete mode 100644 tests/pending/t7126.scala
 rename tests/{run => run-not-optimised}/t4859.check (100%)
 create mode 100644 tests/run-not-optimised/t4859.scala
 create mode 100644 tests/run-not-optimised/t7126.scala

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 8af721ca6cb5..5564033a2d17 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -168,6 +168,10 @@ class CompilationTests extends ParallelTesting {
   @Test def runAll: Unit =
     compileFilesInDir("../tests/run", defaultOptions).checkRuns()
 
+  // The two tests that current fail under -optimise
+  @Test def runNotOptimised: Unit =
+    compileFilesInDir("../tests/run-not-optimised", defaultOptions.filterNot("-optimise".==)).checkRuns()
+
   // Pickling Tests ------------------------------------------------------------
   //
   // Pickling tests are very memory intensive and as such need to be run with a
diff --git a/tests/pending/t7126.scala b/tests/pending/t7126.scala
deleted file mode 100644
index edac56d28d8c..000000000000
--- a/tests/pending/t7126.scala
+++ /dev/null
@@ -1,11 +0,0 @@
-import language._
-
-object Test {
-  type T = Any
-  boom(???): Option[T] // SOE
-  def boom[CC[U]](t : CC[T]): Option[CC[T]] = None
-
-  // okay
-  foo(???): Option[Any]
-  def foo[CC[U]](t : CC[Any]): Option[CC[Any]] = None
-}
diff --git a/tests/run/t4859.check b/tests/run-not-optimised/t4859.check
similarity index 100%
rename from tests/run/t4859.check
rename to tests/run-not-optimised/t4859.check
diff --git a/tests/run-not-optimised/t4859.scala b/tests/run-not-optimised/t4859.scala
new file mode 100644
index 000000000000..8b354ca9451a
--- /dev/null
+++ b/tests/run-not-optimised/t4859.scala
@@ -0,0 +1,29 @@
+object O {
+  case class N()
+  object P
+}
+
+object Outer {
+  println("Outer")
+  object Inner {
+    println("Inner")
+    def i: Unit = {
+      println("Inner.i")
+    }
+  }
+}
+
+object Test {
+  def main(args: Array[String]): Unit = {
+    Outer.Inner.i // we still don't initialize Outer here (but should we?)
+
+    {println("About to reference Inner.i"); Outer}.Inner.i // Outer will be initialized.
+
+    {println("About to reference O.N"        ); O}.N
+
+    {println("About to reference O.N"        ); O}.N
+
+    {println("About to reference O.N.apply()"); O}.N.apply()
+  }
+}
+
diff --git a/tests/run-not-optimised/t7126.scala b/tests/run-not-optimised/t7126.scala
new file mode 100644
index 000000000000..b785bcff69ee
--- /dev/null
+++ b/tests/run-not-optimised/t7126.scala
@@ -0,0 +1,20 @@
+import language._
+
+// Currently typer infers a Nothing as a CC[T] to be Nothing[T], and isn't
+// able to figure out that Nothing[Any] =:= Nothing. We've had a discussion
+// that it should instead infer CC[T] to be type lambda T => Nothing to be
+// kind-correct. #2439
+
+object T7126 {
+  type T = Any
+  boom(???): Option[T] // SOE
+  def boom[CC[U]](t : CC[T]): Option[CC[T]] = None
+
+  // okay
+  foo(???): Option[Any]
+  def foo[CC[U]](t : CC[Any]): Option[CC[Any]] = None
+}
+
+object Test {
+  def main(args: Array[String]): Unit = ()
+}
diff --git a/tests/run/t4859.scala b/tests/run/t4859.scala
index 8b354ca9451a..2dbf1301bd47 100644
--- a/tests/run/t4859.scala
+++ b/tests/run/t4859.scala
@@ -3,6 +3,8 @@ object O {
   object P
 }
 
+// We assume module initialisation to be pure, running this test under
+// -optimise yields different results.
 object Outer {
   println("Outer")
   object Inner {

From e92c40fac495257e76f1d6eed4a12647326eb366 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Tue, 23 May 2017 17:56:58 +0200
Subject: [PATCH 73/88] Fix ShallowFolder

---
 compiler/src/dotty/tools/dotc/ast/Trees.scala | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/Trees.scala b/compiler/src/dotty/tools/dotc/ast/Trees.scala
index 5f33c29158c0..12cfc5e9e0d8 100644
--- a/compiler/src/dotty/tools/dotc/ast/Trees.scala
+++ b/compiler/src/dotty/tools/dotc/ast/Trees.scala
@@ -1190,7 +1190,9 @@ object Trees {
     }
 
     abstract class TreeAccumulator[X] {
+      // Ties the knot of the traversal: call `foldOver(x, tree))` to dive in the `tree` node.
       def apply(x: X, tree: Tree)(implicit ctx: Context): X
+
       def apply(x: X, trees: Traversable[Tree])(implicit ctx: Context): X = (x /: trees)(apply)
       def foldOver(x: X, tree: Tree)(implicit ctx: Context): X = {
         def localCtx =
@@ -1301,7 +1303,7 @@ object Trees {
     class ShallowFolder[X](f: (X, Tree) => X) extends TreeAccumulator[X] {
       def apply(x: X, tree: Tree)(implicit ctx: Context): X = {
         val x1 = f(x, tree)
-        if (x1.asInstanceOf[AnyRef] ne x1.asInstanceOf[AnyRef]) x1
+        if (x1.asInstanceOf[AnyRef] ne x.asInstanceOf[AnyRef]) x1
         else foldOver(x1, tree)
       }
     }

From 8a51d32cd51d939888dab12d42031b659052c2eb Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Tue, 23 May 2017 10:56:19 +0200
Subject: [PATCH 74/88] Do not inline val across class boundaries

---
 .../dotc/transform/linker/Simplify.scala      | 41 +++++++++++++++----
 tests/pos/devalify.scala                      | 11 +++++
 2 files changed, 44 insertions(+), 8 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 1e5551f35253..90fa339d1ed2 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -837,7 +837,6 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         // invalidates the denotation cache. Because this optimization only
         // operates locally, this should be fine.
         val denot = app.fun.symbol.denot
-        simplify.println(s"replacing ${app.symbol}")
         if (!denot.info.finalResultType.derivesFrom(defn.UnitClass)) {
           val newLabelType = app.symbol.info match {
             case mt: MethodType =>
@@ -1113,10 +1112,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   val devalify: Optimization = { implicit ctx: Context =>
     val timesUsed = mutable.HashMap[Symbol, Int]()
     val defined = mutable.HashSet[Symbol]()
+    val usedInInnerClass = mutable.HashMap[Symbol, Int]()
     // Either a duplicate or a read through series of immutable fields
     val copies = mutable.HashMap[Symbol, Tree]()
-    val visitor: Visitor = {
-      case valdef: ValDef if !valdef.symbol.is(Param) &&
+    def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int]): Unit = tree match {
+      case valdef: ValDef if !valdef.symbol.is(Param)                   &&
                              !valdef.symbol.is(Mutable | Module | Lazy) &&
                              valdef.symbol.exists && !valdef.symbol.owner.isClass =>
         defined += valdef.symbol
@@ -1128,8 +1128,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
       case t: New =>
         val symIfExists = t.tpt.tpe.normalizedPrefix.termSymbol
-        val b4 = timesUsed.getOrElseUpdate(symIfExists, 0)
-        timesUsed.put(symIfExists, b4 + 1)
+        val b4 = used.getOrElseUpdate(symIfExists, 0)
+        used.put(symIfExists, b4 + 1)
 
       case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass &&
                              !valdef.symbol.is(Param | Module | Lazy) =>
@@ -1137,11 +1137,36 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         defined += valdef.symbol
 
       case t: RefTree =>
-        val b4 = timesUsed.getOrElseUpdate(t.symbol, 0)
-        timesUsed.put(t.symbol, b4 + 1)
+        val b4 = used.getOrElseUpdate(t.symbol, 0)
+        used.put(t.symbol, b4 + 1)
       case _ =>
     }
 
+    val visitor: Visitor = { tree =>
+      def crossingClassBoundaries(t: Tree): Boolean = t match {
+        case _: New      => true
+        case _: Template => true
+        case _           => false
+      }
+      // We shouldn't inline `This` nodes, which we approximate by not inlining
+      // anything across class boundaries. To do so, we visit every class a
+      // second time and record what's used in the usedInInnerClass Set.
+      if (crossingClassBoundaries(tree)) {
+        // Doing a foreachSubTree(tree) here would work, but would also
+        // be exponential for deeply nested classes. Instead we do a short
+        // circuit traversal that doesn't visit further nested classes.
+        val reVisitClass = new TreeAccumulator[Unit] {
+          def apply(u: Unit, t: Tree)(implicit ctx: Context): Unit = {
+            doVisit(t, usedInInnerClass)
+            if (!crossingClassBoundaries(t))
+              foldOver((), t)
+          }
+        }
+        reVisitClass.foldOver((), tree)
+      }
+      doVisit(tree, timesUsed)
+    }
+
     val transformer: Transformer = () => localCtx => {
       val valsToDrop = defined -- timesUsed.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
@@ -1157,7 +1182,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             case None => Nil
           })
 
-      val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce
+      val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce -- usedInInnerClass.keySet
 
       val deepReplacer = new TreeMap() {
         override def transform(tree: Tree)(implicit ctx: Context): Tree = {
diff --git a/tests/pos/devalify.scala b/tests/pos/devalify.scala
index 87e0193dbf47..b4e4a848cc7f 100644
--- a/tests/pos/devalify.scala
+++ b/tests/pos/devalify.scala
@@ -31,4 +31,15 @@ object Test {
 
     println(subFooBar)
   }
+
+  def test3: Unit = {
+    trait NumericRange {
+      def mapRange: NumericRange = {
+        val self = this
+        new NumericRange {
+          def underlyingRange: NumericRange = self
+        }
+      }
+    }
+  }
 }

From f564340fd909fea0712e22d46bfd4ad7cca53a73 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Tue, 23 May 2017 19:07:21 +0200
Subject: [PATCH 75/88] Minor reformatting

---
 .../dotc/transform/linker/Simplify.scala      | 39 ++++++++++---------
 1 file changed, 21 insertions(+), 18 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 90fa339d1ed2..b8712224af27 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -205,12 +205,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
    */
   val inlineCaseIntrinsics: Optimization = { implicit ctx: Context =>
     val transformer: Transformer = () => localCtx => {
-      case a: Apply if !a.tpe.isInstanceOf[MethodicType]                &&
-                       a.symbol.is(Synthetic)                           &&
-                       a.symbol.owner.is(Module)                        &&
-                       (a.symbol.name == nme.apply)                     &&
-                       a.symbol.owner.companionClass.is(CaseClass)      &&
-                       !a.tpe.derivesFrom(defn.EnumClass)               &&
+      case a: Apply if !a.tpe.isInstanceOf[MethodicType]           &&
+                       a.symbol.is(Synthetic)                      &&
+                       a.symbol.owner.is(Module)                   &&
+                       (a.symbol.name == nme.apply)                &&
+                       a.symbol.owner.companionClass.is(CaseClass) &&
+                       !a.tpe.derivesFrom(defn.EnumClass)          &&
                        (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
         def unrollArgs(t: Tree, l: List[List[Tree]]): List[List[Tree]] = t match {
           case Apply(t, args) => unrollArgs(t, args :: l)
@@ -224,11 +224,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val constructor = a.symbol.owner.companionClass.primaryConstructor.asTerm
         rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head))
 
-      case a: Apply if a.symbol.is(Synthetic)                            &&
-                       a.symbol.owner.is(Module)                         &&
-                       (a.symbol.name == nme.unapply)                    &&
-                       a.symbol.owner.companionClass.is(CaseClass)       &&
-                       !a.tpe.derivesFrom(defn.EnumClass)                &&
+      case a: Apply if a.symbol.is(Synthetic)                       &&
+                       a.symbol.owner.is(Module)                    &&
+                       (a.symbol.name == nme.unapply)               &&
+                       a.symbol.owner.companionClass.is(CaseClass)  &&
+                       !a.tpe.derivesFrom(defn.EnumClass)           &&
                        (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
         if (!a.symbol.owner.is(Scala2x)) {
           if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
@@ -474,7 +474,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       }
     }
     val visitor: Visitor = {
-      case vdef: ValDef if (vdef.symbol.info.classSymbol is CaseClass) && !vdef.symbol.is(Lazy)  && !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Mutable)) =>
+      case vdef: ValDef if (vdef.symbol.info.classSymbol is CaseClass) &&
+                           !vdef.symbol.is(Lazy)                       &&
+                           !vdef.symbol.info.classSymbol.caseAccessors.exists(x => x.is(Mutable)) =>
         followTailPerfect(vdef.rhs, vdef.symbol)
       case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
         checkGood.put(lhs.symbol, checkGood.getOrElse(lhs.symbol, Set.empty) + rhs.symbol)
@@ -898,7 +900,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           cpy.Block(a)(stats = newStats2, newExpr)
         else newExpr
       case a: DefDef =>
-        if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.UnitClass) && !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
+        if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) &&
+            !a.rhs.tpe.derivesFrom(defn.UnitClass)                    &&
+            !a.rhs.tpe.derivesFrom(defn.NothingClass)) {
           def insertUnit(t: Tree) = {
             if (!t.tpe.derivesFrom(defn.UnitClass)) Block(t :: Nil, unitLiteral)
             else t
@@ -1050,7 +1054,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           defined(t.symbol) = t
       case t: RefTree if t.symbol.exists && !t.symbol.is(Method) && !t.symbol.owner.isClass =>
         if (!firstWrite.contains(t.symbol)) firstRead(t.symbol) = t
-      case t @ Assign(l, expr) if  !l.symbol.is(Method) && !l.symbol.owner.isClass =>
+      case t @ Assign(l, expr) if !l.symbol.is(Method) && !l.symbol.owner.isClass =>
         if (!firstRead.contains(l.symbol)) {
           if (firstWrite.contains(l.symbol)) {
             if (!secondWrite.contains(l.symbol))
@@ -1116,8 +1120,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     // Either a duplicate or a read through series of immutable fields
     val copies = mutable.HashMap[Symbol, Tree]()
     def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int]): Unit = tree match {
-      case valdef: ValDef if !valdef.symbol.is(Param)                   &&
-                             !valdef.symbol.is(Mutable | Module | Lazy) &&
+      case valdef: ValDef if !valdef.symbol.is(Param | Mutable | Module | Lazy) &&
                              valdef.symbol.exists && !valdef.symbol.owner.isClass =>
         defined += valdef.symbol
 
@@ -1171,7 +1174,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       val valsToDrop = defined -- timesUsed.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
         val rhs = dropCasts(x._2)
-        rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Method) && !rhs.symbol.is(Mutable))
+        rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Method | Mutable))
       }
       // TODO: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 
@@ -1216,7 +1219,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             New(newTpt)
           }
           else t
-        case t: RefTree if !t.symbol.is(Method) && !t.symbol.is(Param) && !t.symbol.is(Mutable) =>
+        case t: RefTree if !t.symbol.is(Method | Param | Mutable) =>
           if (replacements.contains(t.symbol))
             deepReplacer.transform(replacements(t.symbol)).ensureConforms(t.tpe.widen)
           else t

From 3cc31216487bb1c93e51691aac1742a7d623a106 Mon Sep 17 00:00:00 2001
From: Martin Odersky <odersky@gmail.com>
Date: Fri, 26 May 2017 12:39:18 +0200
Subject: [PATCH 76/88] Add time travelling copies

Make Apply and TypeApply copy only if
function or argument types have changed.
---
 compiler/src/dotty/tools/dotc/ast/tpd.scala   | 56 +++++++++++--------
 .../tools/dotc/transform/MacroTransform.scala |  2 +-
 .../tools/dotc/transform/TreeTransform.scala  |  2 +
 tests/pickling/A.scala                        |  6 ++
 tests/pickling/B.scala                        |  6 ++
 5 files changed, 47 insertions(+), 25 deletions(-)
 create mode 100644 tests/pickling/A.scala
 create mode 100644 tests/pickling/B.scala

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index d1a9555a362c..04cbcb4a485e 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -454,6 +454,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   override val cpy: TypedTreeCopier = // Type ascription needed to pick up any new members in TreeCopier (currently there are none)
     new TypedTreeCopier
 
+  val cpyBetweenPhases = new TimeTravellingTreeCopier
+
   class TypedTreeCopier extends TreeCopier {
     def postProcess(tree: Tree, copied: untpd.Tree): copied.ThisTree[Type] =
       copied.withTypeUnchecked(tree.tpe)
@@ -473,26 +475,24 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     }
 
     override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply = {
-      val untyped = untpd.cpy.Apply(tree)(fun, args)
-      if (untyped.ne(tree) || !ctx.settings.optimise.value)
-        ta.assignType(untyped, fun, args)
-      else
-        tree.asInstanceOf[Apply]
+      val tree1 = untpd.cpy.Apply(tree)(fun, args)
+      tree match {
+        case tree: Apply
+        if (fun.tpe eq tree.fun.tpe) && (args corresponds tree.args)(_ eq _) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, fun, args)
+      }
     }
 
-      // Note: Reassigning the original type if `fun` and `args` have the same types as before
-      // does not work here: The computed type depends on the widened function type, not
-      // the function type itself. A treetransform may keep the function type the
-      // same but its widened type might change.
-
     override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply = {
-      val untyped = untpd.cpy.TypeApply(tree)(fun, args)
-      if (untyped.ne(tree) || !ctx.settings.optimise.value)
-        ta.assignType(untyped, fun, args)
-      else
-        tree.asInstanceOf[TypeApply]
+      val tree1 = untpd.cpy.TypeApply(tree)(fun, args)
+      tree match {
+        case tree: TypeApply
+        if (fun.tpe eq tree.fun.tpe) && (args corresponds tree.args)(_ eq _) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, fun, args)
+      }
     }
-      // Same remark as for Apply
 
     override def Literal(tree: Tree)(const: Constant)(implicit ctx: Context): Literal =
       ta.assignType(untpd.cpy.Literal(tree)(const))
@@ -525,14 +525,8 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
-      val untyped = untpd.cpy.Closure(tree)(env, meth, tpt)
-      val typed = ta.assignType(untyped, meth, tpt)
-      if (untyped.ne(tree) || !ctx.settings.optimise.value)
-        typed
-      else
-        tree.asInstanceOf[Closure]
-    }
+    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure =
+      ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
       // Same remark as for Apply
 
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
@@ -591,6 +585,19 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       Try(tree: Tree)(expr, cases, finalizer)
   }
 
+  class TimeTravellingTreeCopier extends TypedTreeCopier {
+    override def Apply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): Apply =
+      ta.assignType(untpd.cpy.Apply(tree)(fun, args), fun, args)
+      // Note: Reassigning the original type if `fun` and `args` have the same types as before
+      // does not work here: The computed type depends on the widened function type, not
+      // the function type itself. A treetransform may keep the function type the
+      // same but its widened type might change.
+
+    override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply =
+      ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
+      // Same remark as for Apply
+  }
+
   override def skipTransform(tree: Tree)(implicit ctx: Context) = tree.tpe.isError
 
   implicit class TreeOps[ThisTree <: tpd.Tree](val tree: ThisTree) extends AnyVal {
@@ -967,3 +974,4 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     if (file != null && file.exists) new SourceFile(file, Codec(encoding)) else NoSource
   }
 }
+
diff --git a/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala b/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
index 9634decaa166..5ef7b4d9d28c 100644
--- a/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/MacroTransform.scala
@@ -30,7 +30,7 @@ abstract class MacroTransform extends Phase {
    */
   protected def transformPhase(implicit ctx: Context): Phase = this
 
-  class Transformer extends TreeMap {
+  class Transformer extends TreeMap(cpy = cpyBetweenPhases) {
 
     protected def localCtx(tree: Tree)(implicit ctx: Context) = {
       val sym = tree.symbol
diff --git a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala
index b0bd40578c17..3ef6594a3837 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -62,6 +62,8 @@ object TreeTransforms {
 
     def treeTransformPhase: Phase = phase.next
 
+    val cpy = cpyBetweenPhases
+
     def prepareForIdent(tree: Ident)(implicit ctx: Context) = this
     def prepareForSelect(tree: Select)(implicit ctx: Context) = this
     def prepareForThis(tree: This)(implicit ctx: Context) = this
diff --git a/tests/pickling/A.scala b/tests/pickling/A.scala
new file mode 100644
index 000000000000..7de1bc1ef418
--- /dev/null
+++ b/tests/pickling/A.scala
@@ -0,0 +1,6 @@
+import dotty.tools.dotc.core.Decorators._
+import dotty.tools.dotc.core.NameOps._
+
+object Test {
+  "JFunction".toTermName.specializedFor(Nil, ???, Nil, Nil)(???)
+}
diff --git a/tests/pickling/B.scala b/tests/pickling/B.scala
new file mode 100644
index 000000000000..1cdd19a9c2a3
--- /dev/null
+++ b/tests/pickling/B.scala
@@ -0,0 +1,6 @@
+import dotty.tools.dotc.core.Contexts.Context
+
+object Formatting {
+  def rainbows(implicit ctx: Context): String =
+    ctx.settings.color.value.toString
+}

From 8a66a25c4e37c806bf4aa12f7a12e580050634c8 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 May 2017 11:54:27 +0200
Subject: [PATCH 77/88] Simplify: do not drop complex prefixes to case-class
 apply & unapply.

Enable all tests under optimise.
---
 .../dotc/transform/linker/Simplify.scala      | 25 +++++++++++++---
 .../dotty/tools/dotc/CompilationTests.scala   |  5 +---
 tests/run-not-optimised/t4859.scala           | 29 -------------------
 tests/{run-not-optimised => run}/t4859.check  |  0
 tests/{run-not-optimised => run}/t7126.scala  |  0
 5 files changed, 22 insertions(+), 37 deletions(-)
 delete mode 100644 tests/run-not-optimised/t4859.scala
 rename tests/{run-not-optimised => run}/t4859.check (100%)
 rename tests/{run-not-optimised => run}/t7126.scala (100%)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index b8712224af27..c95d3a838d65 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -192,6 +192,22 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     case _ => false
   }
 
+  // Apply fun may be a side-effectful function. E.g. a block, see tests/run/t4859.scala
+  // we need to maintain expressions that were in this block
+  private def evalReciever(a: Apply, res: Tree) = {
+    def receiver(t: Tree):
+    (Tree) = t match {
+      case TypeApply(fun, targs) if fun.symbol eq t.symbol => receiver(fun)
+      case Apply(fn, args) if fn.symbol == t.symbol => receiver(fn)
+      case Select(qual, _) => qual
+      case x => x
+    }
+
+    val recv = receiver(a)
+
+    if (recv.isEmpty || tpd.isPureRef(recv)) res else Block(recv :: Nil, res)
+  }
+
   /** Inline case class specific methods using desugarings assumptions.
    *
    * - CC.apply(args)              → new CC(args)
@@ -230,9 +246,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
                        a.symbol.owner.companionClass.is(CaseClass)  &&
                        !a.tpe.derivesFrom(defn.EnumClass)           &&
                        (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
+
         if (!a.symbol.owner.is(Scala2x)) {
-          if (a.tpe.derivesFrom(defn.BooleanClass)) Literal(Constant(true))
-          else a.args.head
+          if (a.tpe.derivesFrom(defn.BooleanClass)) evalReciever(a, Literal(Constant(true)))
+          else evalReciever(a, a.args.head)
         }
         else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
           def some(e: Tree) = {
@@ -249,7 +266,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           val none = ref(defn.NoneModuleRef)
           def isNull(e: Tree) = e.select(defn.Object_eq).appliedTo(Literal(Constant(null)))
           def fi(e: Tree) = If(isNull(e), none, some(e))
-          evalOnce(a.args.head)(fi)
+          evalReciever(a, evalOnce(a.args.head)(fi))
         }
         else a
       case a: Apply if (a.symbol.name == nme.unapplySeq)           &&
@@ -269,7 +286,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
         val recv = reciever(a)
         if (recv.typeSymbol.is(Module))
-          New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil)
+          evalReciever(a, New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil))
         else a
       case t => t
     }
diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 5564033a2d17..b4e6112baa85 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -167,10 +167,7 @@ class CompilationTests extends ParallelTesting {
 
   @Test def runAll: Unit =
     compileFilesInDir("../tests/run", defaultOptions).checkRuns()
-
-  // The two tests that current fail under -optimise
-  @Test def runNotOptimised: Unit =
-    compileFilesInDir("../tests/run-not-optimised", defaultOptions.filterNot("-optimise".==)).checkRuns()
+  
 
   // Pickling Tests ------------------------------------------------------------
   //
diff --git a/tests/run-not-optimised/t4859.scala b/tests/run-not-optimised/t4859.scala
deleted file mode 100644
index 8b354ca9451a..000000000000
--- a/tests/run-not-optimised/t4859.scala
+++ /dev/null
@@ -1,29 +0,0 @@
-object O {
-  case class N()
-  object P
-}
-
-object Outer {
-  println("Outer")
-  object Inner {
-    println("Inner")
-    def i: Unit = {
-      println("Inner.i")
-    }
-  }
-}
-
-object Test {
-  def main(args: Array[String]): Unit = {
-    Outer.Inner.i // we still don't initialize Outer here (but should we?)
-
-    {println("About to reference Inner.i"); Outer}.Inner.i // Outer will be initialized.
-
-    {println("About to reference O.N"        ); O}.N
-
-    {println("About to reference O.N"        ); O}.N
-
-    {println("About to reference O.N.apply()"); O}.N.apply()
-  }
-}
-
diff --git a/tests/run-not-optimised/t4859.check b/tests/run/t4859.check
similarity index 100%
rename from tests/run-not-optimised/t4859.check
rename to tests/run/t4859.check
diff --git a/tests/run-not-optimised/t7126.scala b/tests/run/t7126.scala
similarity index 100%
rename from tests/run-not-optimised/t7126.scala
rename to tests/run/t7126.scala

From 65265e65b0bf250fe2f74fcd29f03417cc58d05b Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 May 2017 13:20:16 +0200
Subject: [PATCH 78/88] Simplify: fix build

---
 compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index c95d3a838d65..6b7954c98442 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -194,7 +194,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   // Apply fun may be a side-effectful function. E.g. a block, see tests/run/t4859.scala
   // we need to maintain expressions that were in this block
-  private def evalReciever(a: Apply, res: Tree) = {
+  private def evalReciever(a: Apply, res: Tree)(implicit ctx: Context) = {
     def receiver(t: Tree):
     (Tree) = t match {
       case TypeApply(fun, targs) if fun.symbol eq t.symbol => receiver(fun)

From 7740db517fc5e5e5e2ae4c71ae8671c91eb68330 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 26 May 2017 15:19:01 +0200
Subject: [PATCH 79/88] tpd: handle closures with less copying + use sameTypes

---
 compiler/src/dotty/tools/dotc/ast/tpd.scala | 21 ++++++++++++++++-----
 1 file changed, 16 insertions(+), 5 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
index 04cbcb4a485e..f1337287b28a 100644
--- a/compiler/src/dotty/tools/dotc/ast/tpd.scala
+++ b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -478,7 +478,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val tree1 = untpd.cpy.Apply(tree)(fun, args)
       tree match {
         case tree: Apply
-        if (fun.tpe eq tree.fun.tpe) && (args corresponds tree.args)(_ eq _) =>
+        if (fun.tpe eq tree.fun.tpe) && sameTypes(args, tree.args) =>
           tree1.withTypeUnchecked(tree.tpe)
         case _ => ta.assignType(tree1, fun, args)
       }
@@ -488,7 +488,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       val tree1 = untpd.cpy.TypeApply(tree)(fun, args)
       tree match {
         case tree: TypeApply
-        if (fun.tpe eq tree.fun.tpe) && (args corresponds tree.args)(_ eq _) =>
+        if (fun.tpe eq tree.fun.tpe) && sameTypes(args, tree.args) =>
           tree1.withTypeUnchecked(tree.tpe)
         case _ => ta.assignType(tree1, fun, args)
       }
@@ -525,10 +525,15 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
       }
     }
 
-    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure =
-      ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
-      // Same remark as for Apply
 
+    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure = {
+      val tree1 = untpd.cpy.Closure(tree)(env, meth, tpt)
+      tree match {
+        case tree: Closure if sameTypes(env, tree.env) && (meth.tpe eq tree.meth.tpe) && (tpt.tpe eq tree.tpt.tpe) =>
+          tree1.withTypeUnchecked(tree.tpe)
+        case _ => ta.assignType(tree1, meth, tpt)
+      }
+    }
     override def Match(tree: Tree)(selector: Tree, cases: List[CaseDef])(implicit ctx: Context): Match = {
       val tree1 = untpd.cpy.Match(tree)(selector, cases)
       tree match {
@@ -596,6 +601,12 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     override def TypeApply(tree: Tree)(fun: Tree, args: List[Tree])(implicit ctx: Context): TypeApply =
       ta.assignType(untpd.cpy.TypeApply(tree)(fun, args), fun, args)
       // Same remark as for Apply
+    
+    override def Closure(tree: Tree)(env: List[Tree], meth: Tree, tpt: Tree)(implicit ctx: Context): Closure =
+            ta.assignType(untpd.cpy.Closure(tree)(env, meth, tpt), meth, tpt)
+
+    override def Closure(tree: Closure)(env: List[Tree] = tree.env, meth: Tree = tree.meth, tpt: Tree = tree.tpt)(implicit ctx: Context): Closure =
+      Closure(tree: Tree)(env, meth, tpt)
   }
 
   override def skipTransform(tree: Tree)(implicit ctx: Context) = tree.tpe.isError

From 4d54f3d6939737a594c955d20c078a42fe7c7113 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 May 2017 17:35:10 +0200
Subject: [PATCH 80/88] Allow redefining tree-copier per phase.

---
 compiler/src/dotty/tools/dotc/transform/TreeTransform.scala | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala
index 3ef6594a3837..b0eb8e425f9a 100644
--- a/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala
+++ b/compiler/src/dotty/tools/dotc/transform/TreeTransform.scala
@@ -62,7 +62,7 @@ object TreeTransforms {
 
     def treeTransformPhase: Phase = phase.next
 
-    val cpy = cpyBetweenPhases
+    val cpy: TypedTreeCopier = cpyBetweenPhases
 
     def prepareForIdent(tree: Ident)(implicit ctx: Context) = this
     def prepareForSelect(tree: Select)(implicit ctx: Context) = this

From ea7a578f835fd2864de41841b66673a35a77d23c Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 May 2017 17:35:36 +0200
Subject: [PATCH 81/88] Simplify: use a better tree copier.

---
 .../dotc/transform/linker/Simplify.scala      | 25 +++++++++++--------
 1 file changed, 14 insertions(+), 11 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 6b7954c98442..94f3db860ac2 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -34,6 +34,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   private var symmetricOperations: Set[Symbol] = null
   var optimize = false
 
+
+  override val cpy = tpd.cpy
+
   override def prepareForUnit(tree: Tree)(implicit ctx: Context): TreeTransform = {
     SeqFactoryClass = ctx.requiredClass("scala.collection.generic.SeqFactory")
     symmetricOperations = Set(defn.Boolean_&&, defn.Boolean_||, defn.Int_+, defn.Int_*, defn.Long_+, defn.Long_*)
@@ -118,7 +121,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           transformers = transformers.tail
         }
       }
-      if (rhs0 ne tree.rhs) cpy.DefDef(tree)(rhs = rhs0)
+      if (rhs0 ne tree.rhs) tpd.cpy.DefDef(tree)(rhs = rhs0)
       else tree
     } else tree
   }
@@ -539,8 +542,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       def splitWrites(t: Tree, target: Symbol): Tree = {
         t match {
-          case tree@ Block(stats, expr) => cpy.Block(tree)(stats, splitWrites(expr, target))
-          case tree@ If(_, thenp, elsep) => cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
+          case tree@ Block(stats, expr) => tpd.cpy.Block(tree)(stats, splitWrites(expr, target))
+          case tree@ If(_, thenp, elsep) => tpd.cpy.If(tree)(thenp = splitWrites(thenp, target), elsep =  splitWrites(elsep, target))
           case Apply(sel , args) if sel.symbol.isConstructor && t.tpe.widenDealias == target.info.widenDealias.finalResultType.widenDealias =>
             val fieldsByAccessors = newMappings(target)
             var accessors = target.info.classSymbol.caseAccessors.filter(_.isGetter) // TODO: when is this filter needed?
@@ -588,7 +591,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case ddef: DefDef if ddef.symbol.is(Label) =>
           newMappings.get(followCases(ddef.symbol)) match {
             case Some(mappings) =>
-              cpy.DefDef(ddef)(rhs = splitWrites(ddef.rhs, followCases(ddef.symbol)))
+              tpd.cpy.DefDef(ddef)(rhs = splitWrites(ddef.rhs, followCases(ddef.symbol)))
             case _ => ddef
           }
         case a: ValDef if toSplit.contains(a.symbol) =>
@@ -597,7 +600,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           val newFields = newMappings(a.symbol).values.toSet
           Thicket(
             newFields.map(x => ValDef(x.asTerm, defaultValue(x.symbol.info.widenDealias))).toList :::
-              List(cpy.ValDef(a)(rhs = splitWrites(a.rhs, a.symbol))))
+              List(tpd.cpy.ValDef(a)(rhs = splitWrites(a.rhs, a.symbol))))
         case ass: Assign =>
           newMappings.get(ass.lhs.symbol) match {
             case None =>   ass
@@ -685,7 +688,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
         val nthenp = dropGoodCastsInStats.transform(thenp)
 
-        cpy.If(t)(thenp = nthenp, elsep = elsep)
+        tpd.cpy.If(t)(thenp = nthenp, elsep = elsep)
       case t => t
     }
     ("dropGoodCasts", BeforeAndAfterErasure, NoVisitor, transformer)
@@ -824,7 +827,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val nthenp = keepOnlySideEffects(thenp)
         val nelsep = keepOnlySideEffects(elsep)
         if (thenp.isEmpty && elsep.isEmpty) keepOnlySideEffects(cond)
-        else cpy.If(t)(
+        else tpd.cpy.If(t)(
           thenp = nthenp.orElse(if (thenp.isInstanceOf[Literal]) thenp else unitLiteral),
           elsep = nelsep.orElse(if (elsep.isInstanceOf[Literal]) elsep else unitLiteral))
       case Select(rec, _) if
@@ -845,7 +848,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case t: Literal if t.tpe.derivesFrom(defn.UnitClass) => expr
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
-        cpy.Block(bl)(stats2, expr2)
+        tpd.cpy.Block(bl)(stats2, expr2)
       case t: Ident if !t.symbol.is(Method | Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
         desugarIdent(t) match {
           case Some(t) => t
@@ -914,7 +917,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => (newStats1, a.expr)
         }
         if (newStats2.nonEmpty)
-          cpy.Block(a)(stats = newStats2, newExpr)
+          tpd.cpy.Block(a)(stats = newStats2, newExpr)
         else newExpr
       case a: DefDef =>
         if (a.symbol.info.finalResultType.derivesFrom(defn.UnitClass) &&
@@ -924,7 +927,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             if (!t.tpe.derivesFrom(defn.UnitClass)) Block(t :: Nil, unitLiteral)
             else t
           }
-          cpy.DefDef(a)(rhs = insertUnit(keepOnlySideEffects(a.rhs)), tpt = TypeTree(defn.UnitType))
+          tpd.cpy.DefDef(a)(rhs = insertUnit(keepOnlySideEffects(a.rhs)), tpt = TypeTree(defn.UnitType))
         } else a
       case t => t
     }
@@ -1120,7 +1123,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           }
 
           if (newStats eq t.stats) t
-          else cpy.Block(t)(newStats, t.expr)
+          else tpd.cpy.Block(t)(newStats, t.expr)
         case tree => tree
       }
 

From d09dbd6116f6108bf31e9bb08b0e4aa5b938d0f1 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 29 May 2017 17:44:21 +0200
Subject: [PATCH 82/88] Fix SimplifyTests

---
 compiler/test/dotty/tools/dotc/SimplifyTests.scala | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/compiler/test/dotty/tools/dotc/SimplifyTests.scala b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
index 5441fe26fd50..be2056dc93cb 100644
--- a/compiler/test/dotty/tools/dotc/SimplifyTests.scala
+++ b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
@@ -77,7 +77,10 @@ trait SimplifyEquivalences { self: DottyBytecodeTest =>
       """,
       """
          |val t = Tuple2(1, "s")
-         |print(new Some(new Tuple2(t._1, t._2)))
+         |print({
+         |  Tuple2 // TODO: teach Simplify that initializing Tuple2 has no effect
+         |  new Some(new Tuple2(t._1, t._2))
+         |})
       """)
 
   @Test def constantFold =

From 822030543c6d3dea6d922e9de6a49f06841498a0 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 May 2017 18:39:39 +0200
Subject: [PATCH 83/88] Simplify: drop more stuff in dropNoEffects.

---
 .../src/dotty/tools/dotc/transform/linker/Analysis.scala    | 5 +++++
 .../src/dotty/tools/dotc/transform/linker/Simplify.scala    | 6 +++---
 2 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala b/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
index 449fdcb42102..2f3ec71038dd 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Analysis.scala
@@ -7,6 +7,7 @@ import core.Contexts._
 import core.NameOps._
 import core.StdNames._
 import core.Symbols._
+import dotty.tools.dotc.core.Flags
 
 object Analysis {
   import tpd._
@@ -35,6 +36,8 @@ object Analysis {
     "scala.Some"
   )
 
+  private val moduleWhiteList = constructorWhiteList.map(x => x + "$")
+
   private val methodsWhiteList = List(
     "java.lang.Math.min",
     "java.lang.Math.max",
@@ -56,6 +59,8 @@ object Analysis {
         true
       case Apply(fun, args) if methodsWhiteList.contains(fun.symbol.fullName.toString) =>
         true
+      case Ident(_) if t.symbol.is(Flags.Module) && (t.symbol.is(Flags.Synthetic) || moduleWhiteList.contains(t.symbol.fullName.toString)) =>
+        true
       case _ =>
         false
       // analisys
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 94f3db860ac2..9d5afb3dff25 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -849,10 +849,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => keepOnlySideEffects(expr).orElse(unitLiteral)
         }
         tpd.cpy.Block(bl)(stats2, expr2)
-      case t: Ident if !t.symbol.is(Method | Lazy) && !t.symbol.info.isInstanceOf[ExprType] =>
+      case t: Ident if !t.symbol.is(Method | Lazy) && !t.symbol.info.isInstanceOf[ExprType] || Analysis.effectsDontEscape(t) =>
         desugarIdent(t) match {
-          case Some(t) => t
-          case None => EmptyTree
+          case Some(t) if !(t.qualifier.symbol.is(Flags.JavaDefined) && t.qualifier.symbol.is(Flags.Package)) => t
+          case _ => EmptyTree
         }
       case app: Apply if app.fun.symbol.is(Label) && !app.tpe.finalResultType.derivesFrom(defn.UnitClass) =>
         // This is "the scary hack". It changes the return type to Unit, then

From 9c6855249a84c42a3b15555649b949ae53e7c9fc Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Mon, 29 May 2017 18:40:04 +0200
Subject: [PATCH 84/88] Simplify: run devalify before erasure.

---
 .../dotc/transform/linker/Simplify.scala      | 24 +++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 9d5afb3dff25..a0ee1d09c95f 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -1135,10 +1135,20 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
   /** Inline vals */
   val devalify: Optimization = { implicit ctx: Context =>
     val timesUsed = mutable.HashMap[Symbol, Int]()
+    val timesUsedAsType = mutable.HashMap[Symbol, Int]()
+
     val defined = mutable.HashSet[Symbol]()
     val usedInInnerClass = mutable.HashMap[Symbol, Int]()
     // Either a duplicate or a read through series of immutable fields
     val copies = mutable.HashMap[Symbol, Tree]()
+    def visitType(tp: Type): Unit = {
+          tp.foreachPart(x => x match {
+            case TermRef(NoPrefix, _) =>
+              val b4 = timesUsedAsType.getOrElseUpdate(x.termSymbol, 0)
+              timesUsedAsType.put(x.termSymbol, b4 + 1)
+            case _ =>
+          })
+    }
     def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int]): Unit = tree match {
       case valdef: ValDef if !valdef.symbol.is(Param | Mutable | Module | Lazy) &&
                              valdef.symbol.exists && !valdef.symbol.owner.isClass =>
@@ -1149,6 +1159,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
             copies.put(valdef.symbol, valdef.rhs)
           case _ =>
         }
+        visitType(valdef.symbol.info)
       case t: New =>
         val symIfExists = t.tpt.tpe.normalizedPrefix.termSymbol
         val b4 = used.getOrElseUpdate(symIfExists, 0)
@@ -1159,6 +1170,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         // TODO: handle params after constructors. Start changing public signatures by eliminating unused arguments.
         defined += valdef.symbol
 
+      case valdef: ValDef => visitType(valdef.symbol.info)
+      case t: DefDef      => visitType(t.symbol.info)
+      case t: Typed       =>
+        visitType(t.tpt.tpe)
+      case t: TypeApply   => t.args.foreach(x => visitType(x.tpe))
       case t: RefTree =>
         val b4 = used.getOrElseUpdate(t.symbol, 0)
         used.put(t.symbol, b4 + 1)
@@ -1191,11 +1207,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     }
 
     val transformer: Transformer = () => localCtx => {
-      val valsToDrop = defined -- timesUsed.keySet
+      val valsToDrop = defined -- timesUsed.keySet -- timesUsedAsType.keySet
       val copiesToReplaceAsDuplicates = copies.filter { x =>
         val rhs = dropCasts(x._2)
         rhs.isInstanceOf[Literal] || (!rhs.symbol.owner.isClass && !rhs.symbol.is(Method | Mutable))
-      }
+      } -- timesUsedAsType.keySet
       // TODO: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 
       val copiesToReplaceAsUsedOnce =
@@ -1203,7 +1219,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           flatMap(x => copies.get(x._1) match {
             case Some(tr) => List((x._1, tr))
             case None => Nil
-          })
+          }) -- timesUsedAsType.keySet
 
       val replacements = copiesToReplaceAsDuplicates ++ copiesToReplaceAsUsedOnce -- usedInInnerClass.keySet
 
@@ -1249,7 +1265,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       transformation
     }
     // See tests/pos/devalify.scala for examples of why this needs to be after Erasure.
-    ("devalify", AfterErasure, visitor, transformer)
+    ("devalify", BeforeAndAfterErasure, visitor, transformer)
   }
 
   /** Inline val with exactly one assignment to a var. For example:

From ce50cfedbe8461318723cf8a4c56a6209e9d6fcf Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 29 May 2017 18:57:23 +0200
Subject: [PATCH 85/88] Refactoring and comments

---
 .../dotc/transform/linker/Simplify.scala      | 275 +++++++++++-------
 1 file changed, 170 insertions(+), 105 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index a0ee1d09c95f..14c5e69d4ec5 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -83,6 +83,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     constantFold                ::
     Nil
 
+  // The entry point of local optimisation: DefDefs
   override def transformDefDef(tree: DefDef)(implicit ctx: Context, info: TransformerInfo): Tree = {
     val ctx0 = ctx
     if (optimize && !tree.symbol.is(Label)) {
@@ -195,35 +196,37 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     case _ => false
   }
 
-  // Apply fun may be a side-effectful function. E.g. a block, see tests/run/t4859.scala
-  // we need to maintain expressions that were in this block
-  private def evalReciever(a: Apply, res: Tree)(implicit ctx: Context) = {
-    def receiver(t: Tree):
-    (Tree) = t match {
-      case TypeApply(fun, targs) if fun.symbol eq t.symbol => receiver(fun)
-      case Apply(fn, args) if fn.symbol == t.symbol => receiver(fn)
-      case Select(qual, _) => qual
-      case x => x
-    }
-
-    val recv = receiver(a)
-
-    if (recv.isEmpty || tpd.isPureRef(recv)) res else Block(recv :: Nil, res)
-  }
-
   /** Inline case class specific methods using desugarings assumptions.
    *
-   * - CC.apply(args)              → new CC(args)
-   * - Seq.unapplySeq(arg)         → new Some(arg)  // where Seq is any companion of type <: SeqFactoryClass
+   * -
+   * -
    *
    * Dotty only:
-   * - CC.unapply(arg): Boolean    → true
+   * -
    *
    * Scala2 only:
-   * - CC.unapply(arg): Option[CC] → new Some(new scala.TupleN(arg._1, ..., arg._N))
+   * -
    */
   val inlineCaseIntrinsics: Optimization = { implicit ctx: Context =>
+    // Apply fun may be a side-effectful function. E.g. a block, see tests/run/t4859.scala
+    // we need to maintain expressions that were in this block
+    def evalReciever(a: Apply, res: Tree) = {
+      def receiver(t: Tree): Tree = t match {
+        case TypeApply(fun, targs) if fun.symbol eq t.symbol => receiver(fun)
+        case Apply(fn, args) if fn.symbol == t.symbol => receiver(fn)
+        case Select(qual, _) => qual
+        case x => x
+      }
+      val recv = receiver(a)
+      if (recv.isEmpty || tpd.isPureRef(recv))
+        res
+      else
+        Block(recv :: Nil, res)
+    }
+
     val transformer: Transformer = () => localCtx => {
+      // For synthetic applies on case classes (both dotty/scalac)
+      // - CC.apply(args) → new CC(args)
       case a: Apply if !a.tpe.isInstanceOf[MethodicType]           &&
                        a.symbol.is(Synthetic)                      &&
                        a.symbol.owner.is(Module)                   &&
@@ -231,6 +234,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
                        a.symbol.owner.companionClass.is(CaseClass) &&
                        !a.tpe.derivesFrom(defn.EnumClass)          &&
                        (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
+
         def unrollArgs(t: Tree, l: List[List[Tree]]): List[List[Tree]] = t match {
           case Apply(t, args) => unrollArgs(t, args :: l)
           case _ => l
@@ -243,6 +247,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         val constructor = a.symbol.owner.companionClass.primaryConstructor.asTerm
         rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head))
 
+      // For synthetic dotty unapplies on case classes:
+      // - CC.unapply(arg): CC → arg
+      // - CC.unapply(arg): Boolean → true, dotty only
+      // - CC.unapply(arg): Option[CC] → new Some(new scala.TupleN(arg._1, ..., arg._N))
       case a: Apply if a.symbol.is(Synthetic)                       &&
                        a.symbol.owner.is(Module)                    &&
                        (a.symbol.name == nme.unapply)               &&
@@ -250,21 +258,33 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
                        !a.tpe.derivesFrom(defn.EnumClass)           &&
                        (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
 
-        if (!a.symbol.owner.is(Scala2x)) {
-          if (a.tpe.derivesFrom(defn.BooleanClass)) evalReciever(a, Literal(Constant(true)))
-          else evalReciever(a, a.args.head)
+        val args = a.args.head
+        val isDottyUnapply = !a.symbol.owner.is(Scala2x)
+        val isScalaOptionUnapply =
+          a.tpe.derivesFrom(defn.OptionClass) &&
+          a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)
+
+        if (isDottyUnapply) { // dotty only
+          if (a.tpe.derivesFrom(defn.BooleanClass))
+            // CC.unapply(arg): Boolean → true
+            evalReciever(a, Literal(Constant(true)))
+          else
+            // CC.unapply(arg): CC → arg
+            evalReciever(a, a.args.head)
         }
-        else if (a.tpe.derivesFrom(defn.OptionClass) && a.args.head.tpe.derivesFrom(a.symbol.owner.companionClass)) {
+        else if (isScalaOptionUnapply) {
+          // CC.unapply(arg): Option[CC] → new Some(new scala.TupleN(arg._1, ..., arg._N))
+          // The output is defined as a Tree => Tree to go thought tpd.evalOnce.
           def some(e: Tree) = {
             val accessors = e.tpe.widenDealias.classSymbol.caseAccessors.filter(_.is(Method))
-            val fields = accessors.map(x => e.select(x).ensureApplied)
-            val tplType = a.tpe.baseArgTypes(defn.OptionClass).head
-            if (fields.tail.nonEmpty) {
-              val tplAlloc = New(tplType, fields)
-              New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), tplAlloc :: Nil)
-            } else { // scalac does not have Tuple1
-              New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), fields.head :: Nil)
-            }
+            val fields    = accessors.map(x => e.select(x).ensureApplied)
+            val tplType   = a.tpe.baseArgTypes(defn.OptionClass).head
+            val someTpe   = a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass)
+
+            if (fields.tail.nonEmpty)
+              New(someTpe, New(tplType, fields) :: Nil)
+            else // scalac does not have Tuple1
+              New(someTpe, fields.head :: Nil)
           }
           val none = ref(defn.NoneModuleRef)
           def isNull(e: Tree) = e.select(defn.Object_eq).appliedTo(Literal(Constant(null)))
@@ -272,24 +292,29 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           evalReciever(a, evalOnce(a.args.head)(fi))
         }
         else a
+
+      // Seq.unapplySeq(arg) → new Some(arg)
+      // Where Seq is any companion of type <: SeqFactoryClass
       case a: Apply if (a.symbol.name == nme.unapplySeq)           &&
                        a.symbol.owner.derivesFrom(SeqFactoryClass) &&
                        a.symbol.extendedOverriddenSymbols.isEmpty  &&
-                       isPureExpr(a.tree) =>
+                       (isPureExpr(a.fun) || a.fun.symbol.is(Synthetic)) =>
+
         def reciever(t: Tree): Type = t match {
-          case t: Apply => reciever(t.fun)
+          case t: Apply     => reciever(t.fun)
           case t: TypeApply => reciever(t.fun)
-          case t: Ident => desugarIdent(t) match {
+          case t: Ident     => desugarIdent(t) match {
             case Some(t) => reciever(t)
             case _ => NoType
           }
-          case t: Select =>
-            t.qualifier.tpe.widenDealias
+          case t: Select => t.qualifier.tpe.widenDealias
         }
 
         val recv = reciever(a)
-        if (recv.typeSymbol.is(Module))
-          evalReciever(a, New(a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass), a.args.head :: Nil))
+        if (recv.typeSymbol.is(Module)) {
+          val someTpe  = a.tpe.translateParameterized(defn.OptionClass, defn.SomeClass)
+          evalReciever(a, New(someTpe, a.args.head :: Nil))
+        }
         else a
       case t => t
     }
@@ -324,7 +349,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t1: Apply =>
         t2 match {
           case t2: Apply =>
-            (t1.symbol == t2.symbol) && (t1.args zip t2.args).forall(x => isSimilar(x._1, x._2)) && isSimilar(t1.fun, t2.fun)
+            (t1.symbol == t2.symbol) &&
+            (t1.args zip t2.args).forall(x => isSimilar(x._1, x._2)) &&
+            isSimilar(t1.fun, t2.fun)
           case _ => false
         }
       case t1: Ident =>
@@ -338,7 +365,9 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case None => t1.symbol eq t2.symbol
         }
       case t1: Select => t2 match {
-        case t2: Select => (t1.symbol eq t2.symbol) && isSimilar(t1.qualifier, t2.qualifier)
+        case t2: Select =>
+          (t1.symbol eq t2.symbol) &&
+          isSimilar(t1.qualifier, t2.qualifier)
         case t2: Ident => desugarIdent(t2) match {
           case Some(t2) => isSimilar(t1, t2)
           case None => false
@@ -346,87 +375,109 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         case _ => false
       }
       case t1: Literal => t2 match {
-        case t2: Literal if t1.const.tag == t2.const.tag && t1.const.value == t2.const.value =>
-          true
+        case t2: Literal =>
+          t1.const.tag   == t2.const.tag &&
+          t1.const.value == t2.const.value
         case _ => false
       }
       case _ => false
     }
 
+    def isBool(tpe: Type): Boolean = tpe.derivesFrom(defn.BooleanClass)
+    def isConst(tpe: Type): Boolean      = tpe.isInstanceOf[ConstantType]
+    def asConst(tpe: Type): ConstantType = tpe.asInstanceOf[ConstantType]
+
     val transformer: Transformer = () => localCtx => { x => preEval(x) match {
       // TODO: include handling of isInstanceOf similar to one in IsInstanceOfEvaluator
       // TODO: include methods such as Int.int2double(see ./tests/pos/harmonize.scala)
       case If(cond1, thenp, elsep) if isSimilar(thenp, elsep) =>
         Block(cond1 :: Nil, thenp)
+
       case If(cond1, If(cond2, thenp2, elsep2), elsep1) if isSimilar(elsep1, elsep2) =>
         If(cond1.select(defn.Boolean_&&).appliedTo(cond2), thenp2, elsep1)
+
       case If(cond1, If(cond2, thenp2, elsep2), elsep1) if isSimilar(elsep1, thenp2) =>
         If(cond1.select(defn.Boolean_!).ensureApplied.select(defn.Boolean_||).appliedTo(cond2), elsep1, elsep2)
+
       case If(cond1, thenp1, If(cond2, thenp2, elsep2)) if isSimilar(thenp1, thenp2) =>
         If(cond1.select(defn.Boolean_||).appliedTo(cond2), thenp1, elsep2)
+
       case If(cond1, thenp1, If(cond2, thenp2, elsep2)) if isSimilar(thenp1, elsep2) =>
         If(cond1.select(defn.Boolean_||).appliedTo(cond2.select(defn.Boolean_!).ensureApplied), thenp1, thenp2)
+
       case If(t: Literal, thenp, elsep) =>
         if (t.const.booleanValue) thenp
         else elsep
-      case ift @ If(cond, thenp: Literal, elsep: Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && thenp.const.booleanValue && !elsep.const.booleanValue =>
-        if (thenp.const.booleanValue && !elsep.const.booleanValue) {
+
+      case ift @ If(cond, thenp: Literal, elsep: Literal)
+        if isBool(ift.tpe) && thenp.const.booleanValue && !elsep.const.booleanValue =>
           cond
-        }  else if (!thenp.const.booleanValue && elsep.const.booleanValue) {
-          cond.select(defn.Boolean_!).ensureApplied
-        } else ??? //should never happen because it would be similar
-      //    the lower two are disabled, as it may make the isSimilar rule not apply for a nested structure of iffs.
-      //    see the example below:
-      //           (b1, b2) match {
-      //             case (true, true) => true
-      //             case (false, false) => true
-      //             case _ => false
-      //           }
-      // case ift @ If(cond, thenp: Literal, elsep) if ift.tpe.derivesFrom(defn.BooleanClass) && thenp.const.booleanValue =>
-      //   //if (thenp.const.booleanValue)
-      //     cond.select(defn.Boolean_||).appliedTo(elsep)
-      //   //else // thenp is false, this tree is bigger then the original
-      //   //  cond.select(defn.Boolean_!).ensureApplied.select(defn.Boolean_&&).appliedTo(elsep)
-      // case ift @ If(cond, thenp, elsep :Literal) if ift.tpe.derivesFrom(defn.BooleanClass) && !elsep.const.booleanValue =>
-      //   cond.select(defn.Boolean_&&).appliedTo(elsep)
-      //   // the other case ins't handled intentionally. See previous case for explanation
+
+      //  the lower two are disabled, as it may make the isSimilar rule not apply for a nested structure of iffs.
+      //  see the example below:
+      //         (b1, b2) match {
+      //           case (true, true) => true
+      //           case (false, false) => true
+      //           case _ => false
+      //         }
+      // case ift @ If(cond, thenp: Literal, elsep)
+      //   if isBool(ift.tpe) && thenp.const.booleanValue =>
+      //     if (thenp.const.booleanValue)
+      //       cond.select(defn.Boolean_||).appliedTo(elsep)
+      //     else // thenp is false, this tree is bigger then the original
+      //       cond.select(defn.Boolean_!).ensureApplied.select(defn.Boolean_&&).appliedTo(elsep)
+      // case ift @ If(cond, thenp, elsep :Literal) if
+      //    isBool(ift.tpe) && !elsep.const.booleanValue =>
+      //       cond.select(defn.Boolean_&&).appliedTo(elsep)
+      //   the other case ins't handled intentionally. See previous case for explanation
+
       case If(t @ Select(recv, _), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         If(recv, elsep, thenp)
+
       case If(t @ Apply(Select(recv, _), Nil), thenp, elsep) if t.symbol eq defn.Boolean_! =>
         If(recv, elsep, thenp)
+
       // TODO: similar trick for comparisons.
       // TODO: handle comparison with min\max values
-      case Apply(meth1 @ Select(Apply(meth2 @ Select(rec, _), Nil), _), Nil) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! =>
-        rec
-      case meth1 @ Select(meth2 @ Select(rec, _), _) if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! && !ctx.erasedTypes =>
-        rec
+      case Apply(meth1 @ Select(Apply(meth2 @ Select(rec, _), Nil), _), Nil)
+        if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! =>
+          rec
+
+      case meth1 @ Select(meth2 @ Select(rec, _), _)
+        if meth1.symbol == defn.Boolean_! && meth2.symbol == defn.Boolean_! && !ctx.erasedTypes =>
+          rec
+
       case t @ Apply(Select(lhs, _), List(rhs)) =>
         val sym = t.symbol
         (lhs, rhs) match {
           case (lhs, Literal(_)) if !lhs.isInstanceOf[Literal] && symmetricOperations.contains(sym) =>
             rhs.select(sym).appliedTo(lhs)
-          case (l , _) if (sym == defn.Boolean_&&) && l.tpe.isInstanceOf[ConstantType]  =>
-            val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
+          case (l, _) if (sym == defn.Boolean_&&) && isConst(l.tpe) =>
+            val const = asConst(l.tpe).value.booleanValue
             if (const) Block(lhs :: Nil, rhs)
             else l
 
-          case (l, x: Literal) if sym == defn.Boolean_== && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+          case (l, x: Literal) if sym == defn.Boolean_== && isBool(l.tpe) && isBool(x.tpe) =>
             if (x.const.booleanValue) l
             else l.select(defn.Boolean_!).ensureApplied
-          case (l, x: Literal) if sym == defn.Boolean_!= && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+
+          case (l, x: Literal) if sym == defn.Boolean_!= && isBool(l.tpe) && isBool(x.tpe) =>
             if (!x.const.booleanValue) l
             else l.select(defn.Boolean_!).ensureApplied
-          case (x: Literal, l) if sym == defn.Boolean_== && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+
+          case (x: Literal, l) if sym == defn.Boolean_== && isBool(l.tpe) && isBool(x.tpe) =>
             if (x.const.booleanValue) l
             else l.select(defn.Boolean_!).ensureApplied
-          case (x: Literal, l) if sym == defn.Boolean_!= && l.tpe.derivesFrom(defn.BooleanClass) && x.tpe.derivesFrom(defn.BooleanClass) =>
+
+          case (x: Literal, l) if sym == defn.Boolean_!= && isBool(l.tpe) && isBool(x.tpe) =>
             if (!x.const.booleanValue) l
             else l.select(defn.Boolean_!).ensureApplied
 
-          case (l: Literal, _) if (sym == defn.Boolean_||) && l.tpe.isInstanceOf[ConstantType]   =>
-            val const = l.tpe.asInstanceOf[ConstantType].value.booleanValue
+          case (l: Literal, _) if (sym == defn.Boolean_||) && isConst(l.tpe)   =>
+            val const = asConst(l.tpe).value.booleanValue
             if (l.const.booleanValue) l
             else Block(lhs :: Nil, rhs)
+
           // case (Literal(Constant(1)), _)    if sym == defn.Int_*  => rhs
           // case (Literal(Constant(0)), _)    if sym == defn.Int_+  => rhs
           // case (Literal(Constant(1L)), _)   if sym == defn.Long_* => rhs
@@ -443,21 +494,25 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           // case (_, Literal(Constant(0L)))  if sym == defn.Long_/ =>
           //   Block(List(lhs),
           //     ref(defn.throwMethod).appliedTo(New(defn.ArithmeticExceptionClass.typeRef, defn.ArithmeticExceptionClass_stringConstructor, Literal(Constant("/ by zero")) :: Nil)))
+
           case _ => t
         }
-      case t: Match if (t.selector.tpe.isInstanceOf[ConstantType] && t.cases.forall(x => x.pat.tpe.isInstanceOf[ConstantType] || (isWildcardArg(x.pat) && x.guard.isEmpty))) =>
-        val selectorValue = t.selector.tpe.asInstanceOf[ConstantType].value
-        val better = t.cases.find(x => isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
-        if (better.nonEmpty) better.get.body
-        else t
-      case t: Literal =>
-        t
-      case t: CaseDef =>
-        t
-      case t if !isPureExpr(t) =>
-        t
+
+      // This case can only be triggered when running Simplify before pattern matching:
+      // case t: Match
+      //   if t.selector.tpe.isInstanceOf[ConstantType] &&
+      //      t.cases.forall { x =>
+      //        x.pat.tpe.isInstanceOf[ConstantType] || (isWildcardArg(x.pat) && x.guard.isEmpty)
+      //      } =>
+      //   val selectorValue = t.selector.tpe.asInstanceOf[ConstantType].value
+      //   val better = t.cases.find(x => isWildcardArg(x.pat) || (x.pat.tpe.asInstanceOf[ConstantType].value eq selectorValue))
+      //   if (better.nonEmpty) better.get.body
+      //   else t
+
+      case t: Literal => t
+      case t: CaseDef => t
+      case t if !isPureExpr(t) => t
       case t =>
-        // TODO: did not manage to trigger this in tests
         val s = ConstFold.apply(t)
         if ((s ne null) && s.tpe.isInstanceOf[ConstantType]) {
           val constant = s.tpe.asInstanceOf[ConstantType].value
@@ -662,28 +717,36 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t @ If(cond, thenp, elsep) =>
         val newTypeTested = collectTypeTests(cond)
         val nullTested = collectNullTests(cond).toSet
-        val testedMap = newTypeTested.foldRight[Map[Symbol, List[Type]]](Map.empty)((x, y) =>
+        val testedMap = newTypeTested.foldRight[Map[Symbol, List[Type]]](Map.empty) { case (x, y) =>
           y + ((x._1, x._2 :: y.getOrElse(x._1, Nil)))
-        )
+        }
         val dropGoodCastsInStats = new TreeMap() {
-          override def transform(tree: Tree)(implicit ctx: Context): Tree = super.transform(tree) match {
-            case t: Block =>
-              val nstats = t.stats.filterConserve({
-                 case TypeApply(fun @ Select(rec, _), List(tp)) if fun.symbol == defn.Any_asInstanceOf =>
-                   !testedMap.getOrElse(rec.symbol, Nil).exists(x => x <:< tp.tpe)
-                 case _ => true
-              })
-              if (nstats eq t.stats) t
-              else Block(nstats, t.expr)
-            case Apply(fun @ Select(lhs, _), List(Literal(const)))
-              if const.tag == Constants.NullTag && (fun.symbol == defn.Object_eq || fun.symbol == defn.Object_ne) && nullTested.contains(lhs.symbol) =>
-              if (fun.symbol == defn.Object_eq) Literal(Constant(false))
-              else Literal(Constant(true))
-            case Apply(fun @ Select(Literal(const), _), List(rhs))
-              if const.tag == Constants.NullTag && (fun.symbol == defn.Object_eq || fun.symbol == defn.Object_ne) && nullTested.contains(rhs.symbol) =>
+          override def transform(tree: Tree)(implicit ctx: Context): Tree = {
+            def applyCondition(fun: Select, tree: Tree, const: Constant): Boolean =
+              const.tag == Constants.NullTag &&
+              (fun.symbol == defn.Object_eq || fun.symbol == defn.Object_ne) &&
+              (nullTested.contains(tree.symbol))
+
+            def applyBody(fun: Select): Tree =
               if (fun.symbol == defn.Object_eq) Literal(Constant(false))
               else Literal(Constant(true))
-            case t => t
+
+            super.transform(tree) match {
+              case t: Block =>
+                val nstats = t.stats.filterConserve({
+                  case TypeApply(fun @ Select(rec, _), List(tp))
+                    if fun.symbol == defn.Any_asInstanceOf =>
+                      !testedMap.getOrElse(rec.symbol, Nil).exists(x => x <:< tp.tpe)
+                  case _ => true
+                })
+                if (nstats eq t.stats) t
+                else Block(nstats, t.expr)
+              case Apply(fun @ Select(lhs, _), List(Literal(const))) if applyCondition(fun, lhs, const) =>
+                applyBody(fun)
+              case Apply(fun @ Select(Literal(const), _), List(rhs)) if applyCondition(fun, rhs, const) =>
+                applyBody(fun)
+              case t => t
+            }
           }
         }
         val nthenp = dropGoodCastsInStats.transform(thenp)
@@ -1072,8 +1135,10 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       case t: ValDef if t.symbol.is(Mutable, Lazy) && !t.symbol.is(Method) && !t.symbol.owner.isClass =>
         if (isPureExpr(t.rhs))
           defined(t.symbol) = t
+
       case t: RefTree if t.symbol.exists && !t.symbol.is(Method) && !t.symbol.owner.isClass =>
         if (!firstWrite.contains(t.symbol)) firstRead(t.symbol) = t
+
       case t @ Assign(l, expr) if !l.symbol.is(Method) && !l.symbol.owner.isClass =>
         if (!firstRead.contains(l.symbol)) {
           if (firstWrite.contains(l.symbol)) {

From de4dd2ccf2bd0b60dffa706b216671698fed8565 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Tue, 30 May 2017 10:07:37 +0200
Subject: [PATCH 86/88] Fix t4859

---
 .../dotc/transform/linker/Simplify.scala      | 17 ++++++++--------
 .../test/dotty/tools/dotc/SimplifyTests.scala | 20 +++++++++----------
 2 files changed, 18 insertions(+), 19 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 14c5e69d4ec5..6928aea0a3c5 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -245,7 +245,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
           case _ => fun
         }
         val constructor = a.symbol.owner.companionClass.primaryConstructor.asTerm
-        rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head))
+        evalReciever(a, rollInArgs(argss.tail, New(a.tpe.widenDealias, constructor, argss.head)))
 
       // For synthetic dotty unapplies on case classes:
       // - CC.unapply(arg): CC → arg
@@ -1207,12 +1207,12 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     // Either a duplicate or a read through series of immutable fields
     val copies = mutable.HashMap[Symbol, Tree]()
     def visitType(tp: Type): Unit = {
-          tp.foreachPart(x => x match {
-            case TermRef(NoPrefix, _) =>
-              val b4 = timesUsedAsType.getOrElseUpdate(x.termSymbol, 0)
-              timesUsedAsType.put(x.termSymbol, b4 + 1)
-            case _ =>
-          })
+      tp.foreachPart(x => x match {
+        case TermRef(NoPrefix, _) =>
+          val b4 = timesUsedAsType.getOrElseUpdate(x.termSymbol, 0)
+          timesUsedAsType.put(x.termSymbol, b4 + 1)
+        case _ =>
+      })
     }
     def doVisit(tree: Tree, used: mutable.HashMap[Symbol, Int]): Unit = tree match {
       case valdef: ValDef if !valdef.symbol.is(Param | Mutable | Module | Lazy) &&
@@ -1237,8 +1237,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       case valdef: ValDef => visitType(valdef.symbol.info)
       case t: DefDef      => visitType(t.symbol.info)
-      case t: Typed       =>
-        visitType(t.tpt.tpe)
+      case t: Typed       => visitType(t.tpt.tpe)
       case t: TypeApply   => t.args.foreach(x => visitType(x.tpe))
       case t: RefTree =>
         val b4 = used.getOrElseUpdate(t.symbol, 0)
diff --git a/compiler/test/dotty/tools/dotc/SimplifyTests.scala b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
index be2056dc93cb..49261fd3ac92 100644
--- a/compiler/test/dotty/tools/dotc/SimplifyTests.scala
+++ b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
@@ -20,23 +20,23 @@ class DottyBytecodeOptimisedTest extends DottyBytecodeTest {
 }
 
 trait SimplifyEquivalences { self: DottyBytecodeTest =>
-  def check(expr1: String, expr2: String, shared: String = ""): Unit = {
+  def check(source: String, expected: String, shared: String = ""): Unit = {
     import ASMConverters._
-    val source =
+    val src =
       s"""
       $shared
       |class A {
       |  def main(): Unit = {
-            $expr1
+            $source
       |  }
       |}
       |class B {
       |  def main(): Unit = {
-            $expr2
+            $expected
       |  }
       |}
       """.stripMargin
-    checkBCode(source) { dir =>
+    checkBCode(src) { dir =>
       def instructions(clazz: String): List[Instruction] = {
         val clsIn   = dir.lookupName(s"$clazz.class", directory = false).input
         val clsNode = loadClassNode(clsIn)
@@ -46,9 +46,9 @@ trait SimplifyEquivalences { self: DottyBytecodeTest =>
       val B = instructions("B")
       val diff = diffInstructions(A, B)
       if (this.isInstanceOf[DottyBytecodeOptimisedTest])
-        assert(A == B, s"Bytecode wasn't same:\n$diff")
+        assert(A == B, s"Bytecode doesn't match: (lhs = source, rhs = expected) \n$diff")
       else
-        assert(A != B, s"Bytecode was the same:\n$diff")
+        assert(A != B, s"Same Bytecodes without -optimise: you are testing the wrong thing!")
     }
   }
 
@@ -62,9 +62,9 @@ trait SimplifyEquivalences { self: DottyBytecodeTest =>
 
   @Test def inlineCaseIntrinsicsDottyApply =
     check(
-      expr1  = "CC.apply(1, 2)",
-      expr2  = "new CC(1, 2)",
-      shared = "case class CC(i: Int, j: Int)")
+      source   = "CC.apply(1, 2)",
+      expected = "new CC(1, 2)",
+      shared   = "case class CC(i: Int, j: Int)")
 
   @Test def inlineCaseIntrinsicsScalacApply =
     check("::.apply(1, Nil)", "new ::(1, Nil)")

From fba0d51b65dfaa6d044dd0e4661985545685474a Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Tue, 30 May 2017 11:34:52 +0200
Subject: [PATCH 87/88] Devalify: also visitType for New nodes

---
 .../dotty/tools/dotc/transform/linker/Simplify.scala   | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index 6928aea0a3c5..d1cd81fc3afd 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -1226,9 +1226,11 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
         }
         visitType(valdef.symbol.info)
       case t: New =>
-        val symIfExists = t.tpt.tpe.normalizedPrefix.termSymbol
+        val normalized = t.tpt.tpe.normalizedPrefix
+        val symIfExists = normalized.termSymbol
         val b4 = used.getOrElseUpdate(symIfExists, 0)
         used.put(symIfExists, b4 + 1)
+        visitType(normalized)
 
       case valdef: ValDef if valdef.symbol.exists && !valdef.symbol.owner.isClass &&
                              !valdef.symbol.is(Param | Module | Lazy) =>
@@ -1279,8 +1281,8 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
       // TODO: if a non-synthetic val is duplicate of a synthetic one, rename a synthetic one and drop synthetic flag?
 
       val copiesToReplaceAsUsedOnce =
-        timesUsed.filter(x => x._2 == 1).
-          flatMap(x => copies.get(x._1) match {
+        timesUsed.filter(x => x._2 == 1)
+          .flatMap(x => copies.get(x._1) match {
             case Some(tr) => List((x._1, tr))
             case None => Nil
           }) -- timesUsedAsType.keySet
@@ -1289,7 +1291,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
       val deepReplacer = new TreeMap() {
         override def transform(tree: Tree)(implicit ctx: Context): Tree = {
-          def loop(tree: Tree):Tree  =
+          def loop(tree: Tree): Tree  =
             tree match {
               case t: RefTree if replacements.contains(t.symbol) =>
                 loop(replacements(t.symbol))

From b7149c957da0c92c03e8646037567a3c4e366495 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Tue, 30 May 2017 15:32:38 +0200
Subject: [PATCH 88/88] Simpler class hiararchy in SimplifyTests to please
 JUnit

---
 .../dotty/tools/dotc/CompilationTests.scala    |  1 -
 .../test/dotty/tools/dotc/SimplifyTests.scala  | 18 +++++++++---------
 2 files changed, 9 insertions(+), 10 deletions(-)

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index b4e6112baa85..8af721ca6cb5 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -167,7 +167,6 @@ class CompilationTests extends ParallelTesting {
 
   @Test def runAll: Unit =
     compileFilesInDir("../tests/run", defaultOptions).checkRuns()
-  
 
   // Pickling Tests ------------------------------------------------------------
   //
diff --git a/compiler/test/dotty/tools/dotc/SimplifyTests.scala b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
index 49261fd3ac92..f22e515a31d2 100644
--- a/compiler/test/dotty/tools/dotc/SimplifyTests.scala
+++ b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
@@ -7,19 +7,19 @@ import dotty.tools.dotc.config.CompilerCommand
 import dotty.tools.dotc.core.Contexts.FreshContext
 import scala.tools.asm.tree.MethodNode
 
-class SimplifyPosTests extends DottyBytecodeOptimisedTest with SimplifyEquivalences
-class SimplifyNegTests extends DottyBytecodeTest          with SimplifyEquivalences
+class SimplifyPosTests extends SimplifyTests(optimise = true)
+class SimplifyNegTests extends SimplifyTests(optimise = false)
 
-class DottyBytecodeOptimisedTest extends DottyBytecodeTest {
+abstract class SimplifyTests(val optimise: Boolean) extends DottyBytecodeTest {
   override protected def initializeCtx(c: FreshContext): Unit = {
     super.initializeCtx(c)
-    val flags = Array("-optimise") // :+ "-Xprint:simplify"
-    val summary = CompilerCommand.distill(flags)(c)
-    c.setSettings(summary.sstate)
+    if (optimise) {
+      val flags = Array("-optimise") // :+ "-Xprint:simplify"
+      val summary = CompilerCommand.distill(flags)(c)
+      c.setSettings(summary.sstate)
+    }
   }
-}
 
-trait SimplifyEquivalences { self: DottyBytecodeTest =>
   def check(source: String, expected: String, shared: String = ""): Unit = {
     import ASMConverters._
     val src =
@@ -45,7 +45,7 @@ trait SimplifyEquivalences { self: DottyBytecodeTest =>
       val A = instructions("A")
       val B = instructions("B")
       val diff = diffInstructions(A, B)
-      if (this.isInstanceOf[DottyBytecodeOptimisedTest])
+      if (optimise)
         assert(A == B, s"Bytecode doesn't match: (lhs = source, rhs = expected) \n$diff")
       else
         assert(A != B, s"Same Bytecodes without -optimise: you are testing the wrong thing!")