More aggressive variable sharing

odersky · odersky · commit b4377dc38e59 · 2017-07-09T19:06:19.000+02:00
Employing label parameters, we can eliminate redundant expressions
systematically. This produces now optimal code for reducable.scala.
diff --git a/compiler/src/dotty/tools/dotc/ast/tpd.scala b/compiler/src/dotty/tools/dotc/ast/tpd.scala
@@ -171,6 +171,13 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
   def SyntheticValDef(name: TermName, rhs: Tree)(implicit ctx: Context): ValDef =
     ValDef(ctx.newSymbol(ctx.owner, name, Synthetic, rhs.tpe.widen, coord = rhs.pos), rhs)
 
+  def DefDef(sym: TermSymbol, tparams: List[TypeSymbol], vparamss: List[List[TermSymbol]],
+             resultType: Type, rhs: Tree)(implicit ctx: Context): DefDef =
+    ta.assignType(
+      untpd.DefDef(sym.name, tparams map TypeDef, vparamss.nestedMap(ValDef(_)),
+                   TypeTree(resultType), rhs),
+      sym)
+
   def DefDef(sym: TermSymbol, rhs: Tree = EmptyTree)(implicit ctx: Context): DefDef =
     ta.assignType(DefDef(sym, Function.const(rhs) _), sym)
 
@@ -199,14 +206,7 @@ object tpd extends Trees.Instance[Type] with TypedTreeInfo {
     val (vparamss, rtp) = valueParamss(mtp)
     val targs = tparams map (_.typeRef)
     val argss = vparamss.nestedMap(vparam => Ident(vparam.termRef))
-    ta.assignType(
-      untpd.DefDef(
-        sym.name,
-        tparams map TypeDef,
-        vparamss.nestedMap(ValDef(_)),
-        TypeTree(rtp),
-        rhsFn(targs)(argss)),
-      sym)
+    DefDef(sym, tparams, vparamss, rtp, rhsFn(targs)(argss))
   }
 
   def TypeDef(sym: TypeSymbol)(implicit ctx: Context): TypeDef =
diff --git a/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala b/compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala
@@ -74,20 +74,23 @@ object PatternMatcher {
     private val initializer = mutable.Map[Symbol, Tree]()
     private val labelled = mutable.Map[Symbol, Plan]()
 
+    private def newVar(rhs: Tree, flags: FlagSet): TermSymbol =
+      ctx.newSymbol(ctx.owner, PatMatStdBinderName.fresh(), Synthetic | Case | flags,
+        sanitize(rhs.tpe), coord = rhs.pos)
+
     /** The plan `let x = rhs in body(x)` where `x` is a fresh variable */
     private def letAbstract(rhs: Tree)(body: Symbol => Plan): Plan = {
-      val vble = ctx.newSymbol(ctx.owner, PatMatStdBinderName.fresh(), Synthetic | Case,
-        sanitize(rhs.tpe), coord = rhs.pos)
+      val vble = newVar(rhs, EmptyFlags)
       initializer(vble) = rhs
       LetPlan(vble, body(vble))
     }
 
     /** The plan `let l = labelled in body(l)` where `l` is a fresh label */
-    private def labelAbstract(labeld: Plan)(body: Plan => Plan): Plan = {
+    private def labelAbstract(labeld: Plan)(body: (=> Plan) => Plan): Plan = {
       val label = ctx.newSymbol(ctx.owner, PatMatCaseName.fresh(), Synthetic | Label | Method,
         MethodType(Nil, resultType))
       labelled(label) = labeld
-      LabelledPlan(label, body(CallPlan(label)))
+      LabelledPlan(label, body(CallPlan(label, Nil)), Nil)
     }
 
     /** Was symbol generated by pattern matcher? */
@@ -127,9 +130,10 @@ object PatternMatcher {
     }
 
     case class LetPlan(sym: TermSymbol, var body: Plan) extends Plan
-    case class LabelledPlan(sym: TermSymbol, var body: Plan) extends Plan
+    case class LabelledPlan(sym: TermSymbol, var body: Plan, var params: List[TermSymbol]) extends Plan
     case class CodePlan(var tree: Tree) extends Plan
-    case class CallPlan(label: TermSymbol) extends Plan
+    case class CallPlan(label: TermSymbol,
+                        var args: List[(/*formal*/TermSymbol, /*actual*/TermSymbol)]) extends Plan
 
     object TestPlan {
       def apply(test: Test, sym: Symbol, pos: Position, ons: Plan, onf: Plan): TestPlan =
@@ -368,16 +372,36 @@ object PatternMatcher {
       }
     }
 
+    private class RefCounter extends PlanTransform {
+      val count = new mutable.HashMap[Symbol, Int] {
+        override def default(key: Symbol) = 0
+      }
+    }
+
     /** Reference counts for all variables and labels */
-    def referenceCount(plan: Plan): collection.Map[Symbol, Int] = {
-      object RefCount extends PlanTransform {
-        val count = new mutable.HashMap[Symbol, Int] {
-          override def default(key: Symbol) = 0
+    private def labelRefCount(plan: Plan): collection.Map[Symbol, Int] = {
+      object refCounter extends RefCounter {
+        override def apply(plan: LabelledPlan): Plan = {
+          apply(plan.body)
+          if (count(plan.sym) != 0) apply(labelled(plan.sym))
+          plan
+        }
+        override def apply(plan: CallPlan): Plan = {
+          count(plan.label) += 1
+          plan
         }
+      }
+      refCounter(plan)
+      refCounter.count
+    }
+
+    /** Reference counts for all variables and labels */
+    private def varRefCount(plan: Plan): collection.Map[Symbol, Int] = {
+      object refCounter extends RefCounter {
         override val treeMap = new TreeMap {
           override def transform(tree: Tree)(implicit ctx: Context) = tree match {
             case tree: Ident =>
-              if (initializer contains tree.symbol) count(tree.symbol) += 1
+              if (isPatmatGenerated(tree.symbol)) count(tree.symbol) += 1
               tree
             case _ =>
               super.transform(tree)
@@ -390,18 +414,18 @@ object PatternMatcher {
           plan
         }
         override def apply(plan: LabelledPlan): Plan = {
+          apply(labelled(plan.sym))
           apply(plan.body)
-          if (count(plan.sym) != 0)
-            apply(labelled(plan.sym))
           plan
         }
         override def apply(plan: CallPlan): Plan = {
-          count(plan.label) += 1
+          for ((formal, actual) <- plan.args)
+            if (count(formal) != 0) count(actual) += 1
           plan
         }
       }
-      RefCount(plan)
-      RefCount.count
+      refCounter(plan)
+      refCounter.count
     }
 
     /** Rewrite everywhere
@@ -421,13 +445,13 @@ object PatternMatcher {
     object hoistLabels extends PlanTransform {
       override def apply(plan: TestPlan): Plan =
         plan.onSuccess match {
-          case lp @ LabelledPlan(sym, body) =>
+          case lp @ LabelledPlan(sym, body, _) =>
             plan.onSuccess = body
             lp.body = plan
             apply(lp)
           case _ =>
             plan.onFailure match {
-              case lp @ LabelledPlan(sym, body) =>
+              case lp @ LabelledPlan(sym, body, _) =>
                 plan.onFailure = body
                 lp.body = plan
                 apply(lp)
@@ -552,7 +576,7 @@ object PatternMatcher {
      *  Drop all labels that are not referenced anymore after this.
      */
     private def inlineLabelled(plan: Plan) = {
-      val refCount = referenceCount(plan)
+      val refCount = labelRefCount(plan)
       def toDrop(sym: Symbol) = labelled.contains(sym) && refCount(sym) <= 1
       class Inliner extends PlanTransform {
         override def apply(plan: LabelledPlan): Plan =
@@ -575,8 +599,17 @@ object PatternMatcher {
         }
         override def hashCode: Int = tree.hash
       }
+      type SeenVars = Map[RHS, TermSymbol]
 
-      class Merge(seenVars: Map[RHS, Symbol]) extends PlanTransform {
+      /** The variables known at entry to label */
+      val seenAtLabel = mutable.HashMap[Symbol, SeenVars]()
+
+      /** Parameters of label; these are passed additional variables
+       *  which are known at all callsites.
+       */
+      val paramsOfLabel = mutable.HashMap[Symbol, SeenVars]()
+
+      class Merge(seenVars: SeenVars) extends PlanTransform {
         override val treeMap = new TreeMap {
           override def transform(tree: Tree)(implicit ctx: Context) = tree match {
             case tree: Ident =>
@@ -593,21 +626,49 @@ object PatternMatcher {
         }
 
         override def apply(plan: LetPlan): Plan = {
+          initializer(plan.sym) = apply(initializer(plan.sym))
           val seenVars1 =
             if (isPatmatGenerated(plan.sym)) {
               val thisRhs = new RHS(initializer(plan.sym))
               seenVars.get(thisRhs) match {
                 case Some(seen) =>
                   initializer(plan.sym) = ref(seen)
+                  seenVars
                 case none =>
+                  seenVars.updated(thisRhs, plan.sym)
               }
-              seenVars.updated(thisRhs, plan.sym)
             }
             else seenVars
-          initializer(plan.sym) = apply(initializer(plan.sym))
           plan.body = new Merge(seenVars1)(plan.body)
           plan
         }
+
+        override def apply(plan: LabelledPlan): Plan = {
+          seenAtLabel(plan.sym) = seenVars
+          plan.body = apply(plan.body)
+          val paramsMap = paramsOfLabel.getOrElse(plan.sym, Map())
+          plan.params = paramsMap.values.toList.sortBy(_.name.toString)
+          val seenVars1 = seenVars ++ paramsMap
+          labelled(plan.sym) = new Merge(seenVars1)(labelled(plan.sym))
+          plan
+        }
+
+        override def apply(plan: CallPlan): Plan = {
+          paramsOfLabel(plan.label) = paramsOfLabel.get(plan.label) match {
+            case Some(params) =>
+              params.filter { case (rhs, _) => seenVars.contains(rhs) }
+            case none =>
+              for ((rhs, _) <- seenVars if !seenAtLabel(plan.label).contains(rhs))
+              yield (rhs, newVar(rhs.tree, Param))
+          }
+          plan.args =
+            for {
+              (rhs, actual) <- seenVars.toList
+              formal <- paramsOfLabel(plan.label).get(rhs)
+            }
+            yield (formal -> actual)
+          plan
+        }
       }
       (new Merge(Map()))(plan)
     }
@@ -617,7 +678,7 @@ object PatternMatcher {
      *  Also: hoist cases out of tests using `hoistLabelled`.
      */
     private def inlineVars(plan: Plan): Plan = {
-      val refCount = referenceCount(plan)
+      val refCount = varRefCount(plan)
       val LetPlan(topSym, _) = plan
 
       def toDrop(sym: Symbol) =
@@ -628,7 +689,8 @@ object PatternMatcher {
           override def transform(tree: Tree)(implicit ctx: Context) = tree match {
             case tree: Ident =>
               val sym = tree.symbol
-              if (toDrop(sym)) transform(initializer(sym)) else tree
+              if (toDrop(sym)) transform(initializer(sym))
+              else tree
             case _ =>
               super.transform(tree)
           }
@@ -641,6 +703,16 @@ object PatternMatcher {
             plan
           }
         }
+        override def apply(plan: LabelledPlan): Plan = {
+          plan.params = plan.params.filter(refCount(_) != 0)
+          super.apply(plan)
+        }
+        override def apply(plan: CallPlan): Plan = {
+          plan.args = plan.args
+            .filter(formalActual => refCount(formalActual._1) != 0)
+            .sortBy(_._1.name.toString)
+          plan
+        }
       }
       Inliner(plan)
     }
@@ -758,18 +830,21 @@ object PatternMatcher {
             If(emitCondition(plan).withPos(plan.pos), emit(plan.onSuccess), emit(plan.onFailure))
         case LetPlan(sym, body) =>
           seq(ValDef(sym, initializer(sym).ensureConforms(sym.info)) :: Nil, emit(body))
-        case LabelledPlan(label, body) =>
-          seq(DefDef(label, emit(labelled(label))) :: Nil, emit(body))
+        case LabelledPlan(label, body, params) =>
+          label.info = MethodType.fromSymbols(params, resultType)
+          val labelDef = DefDef(label, Nil, params :: Nil, resultType, emit(labelled(label)))
+          seq(labelDef :: Nil, emit(body))
         case CodePlan(tree) =>
           tree
-        case CallPlan(label) =>
-          ref(label).ensureApplied
+        case CallPlan(label, args) =>
+          ref(label).appliedToArgs(args.map { case (_, actual) => ref(actual) })
       }
     }
 
     /** Pretty-print plan; used for debugging */
     def show(plan: Plan): String = {
-      val refCount = referenceCount(plan)
+      val lrefCount = labelRefCount(plan)
+      val vrefCount = varRefCount(plan)
       val sb = new StringBuilder
       val seen = mutable.Set[Int]()
       def showTest(test: Test) = test match {
@@ -788,18 +863,20 @@ object PatternMatcher {
               showPlan(onf)
             case LetPlan(sym, body) =>
               sb.append(i"Let($sym = ${initializer(sym)}}, ${body.id})")
-              sb.append(s", refcount = ${refCount(sym)}")
+              sb.append(s", refcount = ${vrefCount(sym)}")
               showPlan(body)
-            case LabelledPlan(label, body) =>
+            case LabelledPlan(label, body, params) =>
               val labeld = labelled(label)
-              sb.append(i"Labelled($label = ${labeld.id}, ${body.id})")
-              sb.append(s", refcount = ${refCount(label)}")
+              def showParam(param: Symbol) =
+                i"$param: ${param.info}, refCount = ${vrefCount(param)}"
+              sb.append(i"Labelled($label(${params.map(showParam)}%, %) = ${labeld.id}, ${body.id})")
+              sb.append(s", refcount = ${lrefCount(label)}")
               showPlan(body)
               showPlan(labeld)
             case CodePlan(tree) =>
               sb.append(tree.show)
-            case CallPlan(label) =>
-              sb.append(s"Call($label)")
+            case CallPlan(label, params) =>
+              sb.append(s"Call($label(${params.map(_._2)}%, %)")
           }
         }
       showPlan(plan)
diff --git a/tests/run/reducable.scala b/tests/run/reducable.scala
@@ -0,0 +1,25 @@
+object Test extends App {
+  val xs = List(1, 2, 3)
+
+  object Cons {
+    var count = 0
+
+    def unapply[T](xs: List[T]): Option[(T, List[T])] = {
+      count += 1
+      xs match {
+        case x :: xs1 => Some((x, xs1))
+        case _ => None
+      }
+    }
+  }
+
+  val res = xs match {
+    case Cons(0, Nil) => 1
+    case Cons(_, Nil) => 2
+    case Cons(0, _)   => 3
+    case Cons(1, ys)  => 4
+  }
+
+  assert(res == 4, res)
+  assert(Cons.count ==1, Cons.count)
+}
diff --git a/tests/run/switches.scala b/tests/run/switches.scala
@@ -0,0 +1,32 @@
+import annotation.switch
+object Test extends App {
+
+  val x = 3
+  final val Y = 3
+
+  val x1 = x match {
+    case 0 => 0
+    case 1 => 1
+    case 2 => 2
+    case Y => 3
+  }
+
+  val x2 = (x: @switch) match {
+    case 0 => 0
+    case 1 | 2 => 2
+    case Y => 3
+    case _ => 4
+  }
+
+  val x3 = (x: @switch) match {
+    case '0' if x > 0 => 0
+    case '1' => 1
+    case '2' => 2
+    case '3' => 3
+    case x => 4
+  }
+
+  assert(x1 == 3)
+  assert(x2 == 3)
+  assert(x3 == 4)
+}
