From e5478f7a53c50fc125559e9dd29fdbd4a72ae2c7 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/80] Simplify: initial wip

---
 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 6402faad3a3c4181b43a8d1452dd0e5c2df7de04 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/80] Simplify: more WIP

---
 .../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 7d8786bd5a4a..8f0e207d92d1 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -522,6 +522,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 0386c894f99cde5a9f054617a86c92fdfc0143c0 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/80] 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 e48d70f53262bc9f6236760b7a776f92c8c78222 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/80] 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 b438f932e170a71aa00b18952adf1da2ae03166c 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/80] 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 b934d2856ba8ab5a69156d7c3d68c843c91a6d09 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/80] 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 dd817b64e4867dcd22d6093abaf749dd906be33f 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/80] 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 8f0e207d92d1..6103f7d35c17 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -431,6 +431,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)
@@ -491,6 +498,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 4ad34ee3a3266f1ed437597822ef0b8b331e45b0 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/80] After-rebase fixes

---
 .../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 1349bda2a67b6b4946461ed16f7f054f84a2ead8 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/80] 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 5c98aace984a4e88b3d16c84b279e822e8b32cc3 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/80] Start getting rid from Scala2 compiling artefacts.

---
 .../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 c96ee1e3cdc489538d0e90a58c7d26c1348b97ee 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/80] 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 f26b62eb6dd2bfb54afc0a7f7ae4d87860a77e1e 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/80] 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 b84861a68b16cdc219e1b54a8b7b548302ff5ae3 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/80] 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 356bdc8303c109cfa25b041cbe66869266e9be1d 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/80] 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 639e739ec76ad2cbb99c18510d5655f7bbf922ae 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/80] 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 bc38d7f653f3ef11d5cb8dfbe6fef8b49cedc38f 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/80] 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 9ad8364b29557e7230c6a8ca5e8897157eabceb9 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/80] 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 4eaed86ced28967cf285840824984d3b37538aed 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/80] 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 b5725081b959950506bed8ef4550720eb3e0f109 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/80] 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 c7574602f834a2cd36a346bac152bc2a4598f48d 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/80] 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 bb9dc47da7078aec99dd79b8153bbbcbe934f1f3 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/80] 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 6e7b918ef442b65f139004e16223bf4024a91225 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/80] 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 330272d9eb9cc570dd2de09f37748b2cf8efbf8f 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/80] 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 701c99442577bedc35e57e0b28d01d9bb1922b1e 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/80] 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 5b8ce7438cea89dfb45f8ed2a1c1d7f013b13f6d 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/80] 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 6103f7d35c17..d1e0b726a18a 100644
--- a/compiler/src/dotty/tools/dotc/core/Definitions.scala
+++ b/compiler/src/dotty/tools/dotc/core/Definitions.scala
@@ -400,6 +400,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 205d13940bfa356cc29cbb523a4ec46bcd95de0d 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/80] 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 23dfcbf986e7dd34bdc4291a95fb9f8be9f926ce 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/80] 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 52aa8e74395584fef588dc3e78999cf24922db70 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/80] 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 b2b94f9528dd454a4611e71d46c8ec38092646f0 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/80] 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 dbac9ac694ed5d1a14f26f4dc9c112575f8e56eb 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/80] 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 165de21eae4c9ebddc48b012dd48867b052f0218 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/80] 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 af32e43cd5ddbd8eebabe35f0d8f7e4fd346e664 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/80] 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 d1acbda9b027317d1e2c15082347a3977c987855 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/80] 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 8268b1806ca2de687db02c5f707a503cc7af788a 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/80] 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 32ace53c038bc5e189fd5f171c42ebf7548adf5c 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/80] 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 37066ec7e5a9e24f3c160ef0cc6b5f8944214400 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/80] 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 10a2f37343045c3a2dd631559919bdfffa65abe5 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/80] 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 d2be8f94ace9d599479294a9a26e59ee0b94711b 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/80] 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 6ef58596468f36212d7ba82b3077b1773024d2f2 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/80] 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 75e2856e81aa42d5340ba08d134ba1c46f7b5509 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/80] 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 b903556040fbddc02cad13185b970320e08914fa Mon Sep 17 00:00:00 2001
From: jvican <jorgevc@fastmail.es>
Date: Wed, 7 Sep 2016 22:50:01 +0200
Subject: [PATCH 41/80] 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 bc152a879c2c84ff8dd13fa8f04c564ca1a60db8 Mon Sep 17 00:00:00 2001
From: jvican <jorgevc@fastmail.es>
Date: Wed, 7 Sep 2016 23:49:20 +0200
Subject: [PATCH 42/80] 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 58d90d31efdb06882b5e25a9b7cd25d92ea26db6 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/80] 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 d504664a7cdfd6eee06c8b6131457e3d1f4fd0a9 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/80] 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 bb577ea19be79878debf3fd5ce4d318957ca6c42 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/80] 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 417792e10fe0945fc3af3de541a57a40559a5ca7 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/80] 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 b0b521f30819..2cbe2ad049a6 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`.
@@ -61,6 +61,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
@@ -75,6 +78,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 a5a789d84e3749084c992e21af63da8901b44507 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/80] 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 85542f5560832f7b06fe7f16a139821dc317f8b3 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/80] 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 d44ffd81d92e4cf79d69c1fd129355767054816e 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/80] 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 8cede17c2b47f961c9a4e490b57d62c0f7362687 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/80] 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 25f9a8c311ca4221cfea9af8da8d690b2023c356 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/80] 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 5e4e9668f16ecda76517fc844e499cef3fd6422b 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/80] 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 8822ddbfb0e1f118a6f0a07a55f8fdd2b6386910 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/80] 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 2cbe2ad049a6..17866ebffd4a 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
@@ -61,9 +62,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 01e3c4e00360f20ecb8e4e05705e7ccc0278de5f 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/80] 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 bb9fcadaeef6d97a502182cf8a80f08d5264baa5 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/80] 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 d2f23b9287358de760afcbaa9f38a6bdebdfafcb 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/80] 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 330362290a26..ba58393a4c39 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 81954d16a0c18d66b608ee2d9f3d9a77e72dc525 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/80] 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 c9bb95208b35eb37a8e95824aedd805b2808556e 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/80] 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 67fe148ae963d5fe5b837f1b81125b6562525068 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/80] 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 17866ebffd4a..4ff5a962594b 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -89,9 +89,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 f8107976eb4daecc4eeaafae2cdbd9d36e8c55cd 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/80] 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 301ab23fd52f9d07669edafb1528035bed3797e2 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/80] 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 4ff5a962594b..b7e80d0edd88 100644
--- a/compiler/src/dotty/tools/dotc/Compiler.scala
+++ b/compiler/src/dotty/tools/dotc/Compiler.scala
@@ -89,10 +89,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 2705b70ce38028d027d87aa5d2b53a3acad349d9 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/80] 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 e0c07c6cb5c8626fa0d40554a1f2ad7372617a59 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/80] 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 7fa7b220c3072d1204c13e4a209dbdddef7f62df 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/80] 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 e2e63cd0cc04..ad6734675e98 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 debd4a5eeb4d..91a83f75cb34 100644
--- a/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
+++ b/compiler/src/dotty/tools/dotc/core/SymDenotations.scala
@@ -468,7 +468,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 d62071cc06af9c6c27be5c21283361bfc1d0938f 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/80] 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 6cfefa65c700..dfd2fda15a02 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 e61b70dbc23151578cf496679a4642c83bbd54c0 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/80] 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 950b6ab406e1c0b489b428ea958a3eb807461ba4 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/80] 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 0431c5a5c4fbf69f69515f2efbabd220fb2f5e82 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/80] 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 22e9022907399931c1b7578e6581f08c1f3415da 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/80] 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 120a391ac499d5b345f4faeae684d753e381bec0 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/80] 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 c0e0f9ce1fc8d7cc7fda4a920fcfc9f0dfaa4199 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/80] 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 8d490aeab21a7b6ef73273335c1f99a27bbab30c 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/80] 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 44aff1be3c7db70b5f1e30b9432cb026b71c64fb 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/80] 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 7a03550a11ad5836b548ac8012eca11b995ef86b 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/80] 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 935858c99482c38ad3a300ad3e6cf77850fe05f1 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/80] 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 baf43abee27f66955306b6caa4dc80cd1317c123 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/80] 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 80612fd9ea530d3ca74e84f4180abd9fa544e805 Mon Sep 17 00:00:00 2001
From: Dmitry Petrashko <dmitry.petrashko@gmail.com>
Date: Fri, 26 May 2017 13:32:52 +0200
Subject: [PATCH 77/80] Use tpd.cpy in Simplify.

---
 compiler/src/dotty/tools/dotc/transform/TreeTransform.scala   | 2 +-
 compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala | 1 +
 2 files changed, 2 insertions(+), 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
diff --git a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
index b8712224af27..6a415a2d8772 100644
--- a/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
+++ b/compiler/src/dotty/tools/dotc/transform/linker/Simplify.scala
@@ -32,6 +32,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
 
   private var SeqFactoryClass: Symbol = null
   private var symmetricOperations: Set[Symbol] = null
+  override val cpy = tpd.cpy
   var optimize = false
 
   override def prepareForUnit(tree: Tree)(implicit ctx: Context): TreeTransform = {

From 3c536d6245612e865c8e1565c04d3c09b5170c9c 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 78/80] 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 71f06ef16f9a54952452d3ed5ccd23b78b02a8c3 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 29 May 2017 09:58:02 +0200
Subject: [PATCH 79/80] Simpler class hiararchy in SimplifyTests to please
 JUnit

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

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 5564033a2d17..08261d03d755 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -168,7 +168,7 @@ class CompilationTests extends ParallelTesting {
   @Test def runAll: Unit =
     compileFilesInDir("../tests/run", defaultOptions).checkRuns()
 
-  // The two tests that current fail under -optimise
+  // The two tests that currently fail under -optimise
   @Test def runNotOptimised: Unit =
     compileFilesInDir("../tests/run-not-optimised", defaultOptions.filterNot("-optimise".==)).checkRuns()
 
diff --git a/compiler/test/dotty/tools/dotc/SimplifyTests.scala b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
index 5441fe26fd50..1e777fd70197 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(expr1: String, expr2: String, shared: String = ""): Unit = {
     import ASMConverters._
     val source =
@@ -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 wasn't same:\n$diff")
       else
         assert(A != B, s"Bytecode was the same:\n$diff")

From befa11fbc30345659eaf7f21fb16ccbad983ed75 Mon Sep 17 00:00:00 2001
From: Olivier Blanvillain <olivier.blanvillain@gmail.com>
Date: Mon, 29 May 2017 11:03:11 +0200
Subject: [PATCH 80/80] Restore t7126

---
 compiler/test/dotty/tools/dotc/CompilationTests.scala | 2 +-
 tests/{run-not-optimised => run}/t7126.scala          | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename tests/{run-not-optimised => run}/t7126.scala (100%)

diff --git a/compiler/test/dotty/tools/dotc/CompilationTests.scala b/compiler/test/dotty/tools/dotc/CompilationTests.scala
index 08261d03d755..98d8cb10f857 100644
--- a/compiler/test/dotty/tools/dotc/CompilationTests.scala
+++ b/compiler/test/dotty/tools/dotc/CompilationTests.scala
@@ -168,7 +168,7 @@ class CompilationTests extends ParallelTesting {
   @Test def runAll: Unit =
     compileFilesInDir("../tests/run", defaultOptions).checkRuns()
 
-  // The two tests that currently fail under -optimise
+  // For the single test that currently fail under -optimise
   @Test def runNotOptimised: Unit =
     compileFilesInDir("../tests/run-not-optimised", defaultOptions.filterNot("-optimise".==)).checkRuns()
 
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