Reimplement (simplified version of) InlineLocalObjects

OlivierBlanvillain · OlivierBlanvillain · commit df617b3a9bcf · 2017-06-26T16:12:22.000+02:00
diff --git a/compiler/src/dotty/tools/dotc/core/NameKinds.scala b/compiler/src/dotty/tools/dotc/core/NameKinds.scala
@@ -310,9 +310,8 @@ 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")
+
+  val LocalOptInlineLocalObj  = new UniqueNameKind("ilo")
 
   /** The kind of names of default argument getters */
   val DefaultGetterName = new NumberedNameKind(DEFAULTGETTER, "DefaultGetter") {
diff --git a/compiler/src/dotty/tools/dotc/transform/localopt/InlineLocalObjects.scala b/compiler/src/dotty/tools/dotc/transform/localopt/InlineLocalObjects.scala
@@ -5,6 +5,7 @@ import core.Constants.Constant
 import core.Contexts.Context
 import core.Decorators._
 import core.Names.Name
+import core.NameKinds.LocalOptInlineLocalObj
 import core.Types.Type
 import core.StdNames._
 import core.Symbols._
@@ -15,200 +16,98 @@ import transform.SymUtils._
 import config.Printers.simplify
 import Simplify._
 
-/** Inline case classes as vals.
+/** Rewrite fields of local instances as vals.
  *
- *  In other words, implements (local) multi parameter value classes. The main
- *  motivation is to get ride of all the intermediate tuples created by the
- *  pattern matcher.
+ *  If a local instance does not escape the local scope, it will be removed
+ *  later by DropNoEffects, thus implementing the equivalent of (local) multi
+ *  parameter value classes. The main motivation for this transformation is to
+ *  get ride of the intermediate tuples object somes created when pattern
+ *  matching on Scala2 case classes.
  */
-class InlineLocalObjects extends Optimisation {
+class InlineLocalObjects(val simplifyPhase: Simplify) extends Optimisation {
   import ast.tpd._
 
-  // 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]()
+  // ValDefs whose rhs is a case class instantiation: potential candidates.
+  val candidates = mutable.HashSet[Symbol]()
 
+  // ValDefs whose lhs is used with `._1` (or any getter call).
   val gettersCalled = mutable.HashSet[Symbol]()
 
-  def symbolAccessors(s: Symbol)(implicit ctx: Context): List[Symbol] = {
-    val accessors = s.info.classSymbol.caseAccessors.filter(_.isGetter)
-    if (accessors.isEmpty)
-      s.info.classSymbol.caseAccessors
-    else accessors
-  }
-
-  def followTailPerfect(t: Tree, symbol: Symbol)(implicit ctx: Context): Unit = {
-    t match {
-      case Block(_, expr) =>
-        followTailPerfect(expr, symbol)
-
-      case If(_, thenp, elsep) =>
-        followTailPerfect(thenp, symbol)
-        followTailPerfect(elsep, symbol)
+  // Map from class to new fields, initialised between visitor and transformer.
+  var newFieldsMapping: Map[Symbol, Map[Symbol, Symbol]] = null
+  //                   |           |       |
+  //                   |           |       New fields, replacements these getters
+  //                   |           Usages of getters of these classes
+  //                   ValDefs of the classes that are being torn apart; = candidates.intersect(gettersCalled)
 
-      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(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
-
-      case t: Ident if !t.symbol.owner.isClass && (t.symbol ne symbol) =>
-        checkGood.put(symbol, checkGood.getOrElse(symbol, Set.empty) + t.symbol)
+  def clear(): Unit = {
+    candidates.clear()
+    gettersCalled.clear()
+    newFieldsMapping = null
+  }
 
-      case _ =>
+  def initNewFieldsMapping()(implicit ctx: Context): Unit =
+    if (newFieldsMapping == null) {
+      newFieldsMapping = candidates.intersect(gettersCalled).map { refVal =>
+        val accessors = refVal.info.classSymbol.caseAccessors.filter(_.isGetter)
+        val newLocals = accessors.map { x =>
+          val owner: Symbol  = refVal.owner
+          val name:  Name    = LocalOptInlineLocalObj.fresh()
+          val flags: FlagSet = Synthetic
+          val info:  Type    = x.asSeenFrom(refVal.info).info.finalResultType.widenDealias
+          ctx.newSymbol(owner, name, flags, info)
+        }
+        (refVal, accessors.zip(newLocals).toMap)
+      }.toMap
     }
+
+  // Pattern for candidates to this optimisation: ValDefs where the rhs is an
+  // immutable case class instantiation.
+  object NewCaseClassValDef {
+    def unapply(t: ValDef)(implicit ctx: Context): Option[(Tree, List[Tree])] =
+      t.rhs match {
+        case Apply(fun, args) =>
+          val isCaseClass   = t.symbol.info.classSymbol is CaseClass
+          val isVal         = !t.symbol.is(Lazy | Mutable)
+          val notMutableCC  = !t.symbol.info.classSymbol.caseAccessors.exists(_.is(Mutable))
+          val isConstructor = fun.symbol.isConstructor
+          // Rules out case class inheritance and enums
+          val notWeirdCC    = t.tpe.widenDealias == t.symbol.info.widenDealias.finalResultType.widenDealias
+          if (isCaseClass && isVal && notMutableCC && isConstructor && notWeirdCC)
+            Some((fun, args))
+          else None
+        case _ => None
+      }
   }
 
   def visitor(implicit ctx: Context): Tree => Unit = {
-    case t: ValDef if (t.symbol.info.classSymbol is CaseClass) &&
-                      !t.symbol.is(Lazy)                       &&
-                      !t.symbol.info.classSymbol.caseAccessors.exists(_.is(Mutable)) =>
-      followTailPerfect(t.rhs, t.symbol)
-
-    case Assign(lhs, rhs) if !lhs.symbol.owner.isClass =>
-      checkGood.put(lhs.symbol, checkGood.getOrElse(lhs.symbol, Set.empty) + rhs.symbol)
-
+    case t @ NewCaseClassValDef(fun, args) =>
+      candidates += t.symbol
     case t @ Select(qual, _) if isImmutableAccessor(t) =>
-      gettersCalled(qual.symbol) = true
-
-    case t: DefDef if t.symbol.is(Label) =>
-      followTailPerfect(t.rhs, t.symbol)
-
+      gettersCalled += qual.symbol
     case _ =>
   }
 
   def transformer(implicit ctx: Context): Tree => Tree = {
-    var hasChanged = true
-    while (hasChanged) {
-      hasChanged = false
-      checkGood.foreach { case (key, values) =>
-        values.foreach { value =>
-          if (hasPerfectRHS.getOrElse(key, false)) {
-            hasChanged = !hasPerfectRHS.put(value, true).getOrElse(false)
-          }
-        }
-      }
-    }
-
-    val newMappings: Map[Symbol, Map[Symbol, Symbol]] =
-      hasPerfectRHS.iterator
-          .map(_._1)
-          .filter(x => !x.is(Method | 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
-            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 optimisation that
-              // TODO: is capable of turning those mutable ones into immutable in common cases
-              val owner: Symbol  = ctx.owner.enclosingMethod
-              val name:  Name    = (refVal.name + "$" + x.name).toTermName
-              val flags: FlagSet = Synthetic | Mutable
-              val info:  Type    = x.asSeenFrom(refVal.info).info.finalResultType.widenDealias
-              ctx.newSymbol(owner, name, flags, info)
-            }
-            val fieldMapping = accessors 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)
-          var accessors = symbolAccessors(target)
-          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(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 = symbolAccessors(target)
-          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 =>
-            if (ev.tpe.derivesFrom(defn.NothingClass)) ev
-            else {
-              val fieldsByAccessors = newMappings(target)
-              val accessors = symbolAccessors(target)
-              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, 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)
-        // 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()
-    // checkGood.clear()
-    gettersCalled.clear()
-
-    val res: Tree => Tree = {
-      case t: DefDef if t.symbol.is(Label) =>
-        newMappings.get(followCases(t.symbol)) match {
-          case Some(mappings) =>
-            cpy.DefDef(t)(rhs = splitWrites(t.rhs, followCases(t.symbol)))
-          case _ => t
-        }
-
-      case t: ValDef if toSplit.contains(t.symbol) =>
-        toSplit -= t.symbol
-        // Break ValDef apart into fields + boxed value
-        val newFields = newMappings(t.symbol).values.toSet
-        Thicket(
-          newFields.map(x => ValDef(x.asTerm, defaultValue(x.symbol.info.widenDealias))).toList :::
-            List(cpy.ValDef(t)(rhs = splitWrites(t.rhs, t.symbol))))
-
-      case t: Assign =>
-        newMappings.get(t.lhs.symbol) match {
-          case None =>   t
-          case Some(mapping) =>
-            val updates = mapping.filter(x => x._1.is(CaseAccessor)).map(x => ref(x._2).becomes(ref(t.lhs.symbol).select(x._1))).toList
-            Thicket(t :: updates)
+    initNewFieldsMapping();
+    {
+      case t @ NewCaseClassValDef(fun, args) if newFieldsMapping.contains(t.symbol) =>
+        val newFields     = newFieldsMapping(t.symbol).values.toList
+        val newFieldsDefs = newFields.zip(args).map { case (nf, arg) =>
+          val rhs = arg.changeOwnerAfter(t.symbol, nf.symbol, simplifyPhase)
+          ValDef(nf.asTerm, rhs)
         }
+        val recreate      = cpy.ValDef(t)(rhs = fun.appliedToArgs(newFields.map(x => ref(x))))
+        simplify.println(s"Replacing ${t.symbol.fullName} with stack-allocated fields ($newFields)")
+        Thicket(newFieldsDefs :+ recreate)
 
       case t @ Select(rec, _) if isImmutableAccessor(t) =>
-        newMappings.getOrElse(rec.symbol, Map.empty).get(t.symbol) match {
-          case None => t
+        newFieldsMapping.getOrElse(rec.symbol, Map.empty).get(t.symbol) match {
+          case None         => t
           case Some(newSym) => ref(newSym)
         }
 
       case t => t
     }
-    res
   }
 }
diff --git a/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala b/compiler/src/dotty/tools/dotc/transform/localopt/Simplify.scala
@@ -48,7 +48,7 @@ class Simplify extends MiniPhaseTransform with IdentityDenotTransformer {
     new Jumpjump                    ::
     new DropGoodCasts               ::
     new DropNoEffects(this)         ::
-    new InlineLocalObjects          :: // followCases needs to be fixed, see ./tests/pos/rbtree.scala
+    new InlineLocalObjects(this)    ::
     // new Varify                      :: // varify could stop other transformations from being applied. postponed.
     // new BubbleUpNothing             ::
     new ConstantFold(this)          ::
diff --git a/compiler/test/dotty/tools/dotc/SimplifyTests.scala b/compiler/test/dotty/tools/dotc/SimplifyTests.scala
@@ -76,11 +76,7 @@ abstract class SimplifyTests(val optimise: Boolean) extends DottyBytecodeTest {
          |print(Tuple2.unapply(t))
       """,
       """
-         |val t = Tuple2(1, "s")
-         |print({
-         |  Tuple2 // TODO: teach Simplify that initializing Tuple2 has no effect
-         |  new Some(new Tuple2(t._1, t._2))
-         |})
+         |print(new Some(new Tuple2(1, "s")))
       """)
 
   @Test def constantFold =
@@ -97,20 +93,84 @@ abstract class SimplifyTests(val optimise: Boolean) extends DottyBytecodeTest {
   @Test def dropNoEffects =
     check(
       """
-         |"wow"
+         |val a = "wow"
          |print(1)
       """,
       """
          |print(1)
       """)
 
-  // @Test def inlineOptions =
+  @Test def dropNoEffectsTuple =
+    check("new Tuple2(1, 3)", "")
+
+  @Test def inlineLocalObjects =
+    check(
+      """
+         |val t = new Tuple2(1, 3)
+         |print(t._1 + t._2)
+      """,
+      """
+         |val i = 3
+         |print(1 + i) // Prevents typer from constant folding 1 + 3 to 4
+      """)
+
+  @Test def inlineOptions =
+    check(
+      """
+         |val sum = Some("s")
+         |println(sum.isDefined)
+      """,
+      """
+         |println(true)
+      """)
+
+  // @Test def listPatmapExample =
+  //   check(
+  //     """
+  //        |val l = 1 :: 2 :: Nil
+  //        |l match {
+  //        |  case Nil => print("nil")
+  //        |  case x :: xs => print(x)
+  //        |}
+  //     """,
+  //     """TODO
+  //     """)
+
+  // @Test def fooCCExample =
+  //   check(
+  //     source   =
+  //     """
+  //       |val x: Any = new Object {}
+  //       |val (a, b) = x match {
+  //       |  case CC(s @ 1, CC(t, _)) =>
+  //       |    (s , 2)
+  //       |  case _ => (42, 43)
+  //       |}
+  //       |a + b
+  //     """,
+  //     expected =
+  //     """TODO
+  //     """,
+  //     shared   = "case class CC(a: Int, b: Object)")
+
+  // @Test def booleansFunctionExample =
   //   check(
   //     """
-  //        |val sum = Some("s")
-  //        |println(sum.isDefined)
+  //     |val a: Any = new Object {}
+  //     |val (b1, b2) = (a.isInstanceOf[String], a.isInstanceOf[List[Int]])
+  //     |(b1, b2) match {
+  //     |  case (true, true) => true
+  //     |  case (false, false) => true
+  //     |  case _ => false
+  //     |}
   //     """,
   //     """
-  //        |println(true)
+  //     |val a: Any = new Object {}
+  //     |val bl = a.isInstanceOf[List[_]]
+  //     |val bl2 = a.isInstanceOf[String]
+  //     |if (true == bl2 && true == bl)
+  //     |  true
+  //     |else
+  //     |  false == bl2 && false == bl
   //     """)
 }
