Cleanup.

Author: sjrd

compiler/src/dotty/tools/dotc/transform/PatternMatcher.scala

@@ -68,10 +68,10 @@ object PatternMatcher {
    *    - emit the translated tree, using methods `emit`, `collectSwitchCases`,
    *      `emitSwitchCases`, and `emitCondition`.
    *
-   *  A plan represents the underlying decision graph. It consists
-   *  of tests, let and label bindings, calls to labels and code blocks.
-   *  It's represented by its own data type. Plans are optimized by
-   *  inlining, hoisting, and the elimination of redundant tests and dead code.
+   *  A plan represents the underlying decision graph. It consists of tests,
+   *  let bindings, labeled blocks, return from said labeled blocks and code blocks.
+   *  It's represented by its own data type. Plans are optimized by merging common
+   *  tests and eliminating dead code.
    */
   class Translator(resultType: Type, thisPhase: MiniPhase)(implicit ctx: Context) {
 
@@ -104,13 +104,6 @@ object PatternMatcher {
       LabeledPlan(label, expr(ReturnPlan(label)))
     }
 
-    /** The plan `l: { expr(l) }` where `l` is a fresh label */
-    private def labeledAbstract2(expr: TermSymbol => Plan): Plan = {
-      val label = ctx.newSymbol(ctx.owner, PatMatCaseName.fresh(), Synthetic | Label,
-        defn.UnitType)
-      LabeledPlan(label, expr(label))
-    }
-
     /** Test whether a type refers to a pattern-generated variable */
     private val refersToInternal = new TypeAccumulator[Boolean] {
       def apply(x: Boolean, tp: Type) =
@@ -505,6 +498,9 @@ object PatternMatcher {
      *  }
      *
      *  where plan2[x1/x2] means substituting x1 for x2 in plan2.
+     *
+     *  There are some tricks to "ignore" non-patmat-generated let bindings, i.e.,
+     *  captures written in the source code, while identifying common subplans.
      */
     def mergeTests(plan: Plan): Plan = {
       class SubstituteIdent(from: TermSymbol, to: TermSymbol) extends PlanTransform {
@@ -574,95 +570,6 @@ object PatternMatcher {
       new MergeTests()(plan)
     }
 
-    /** Merge variables that have the same right hand side.
-     *  Propagate common variable bindings as parameters into case labels.
-     */
-    /*
-    private def mergeVars(plan: Plan): Plan = {
-      class RHS(val tree: Tree) {
-        override def equals(that: Any) = that match {
-          case that: RHS => this.tree === that.tree
-          case _ => false
-        }
-        override def hashCode: Int = tree.hash
-      }
-      type SeenVars = Map[RHS, TermSymbol]
-
-      /** The variables known at entry to label */
-      val seenAtLabel = newMutableSymbolMap[SeenVars]
-
-      /** Parameters of label; these are passed additional variables
-       *  which are known at all callsites.
-       */
-      val paramsOfLabel = newMutableSymbolMap[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 =>
-              val sym = tree.symbol
-              initializer.get(sym) match {
-                case Some(id: Ident @unchecked)
-                if isPatmatGenerated(sym) && isPatmatGenerated(id.symbol) =>
-                  transform(id)
-                case none => tree
-              }
-            case _ =>
-              super.transform(tree)
-          }
-        }
-
-        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)
-              }
-            }
-            else seenVars
-          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))
-          }
-          val newArgs =
-            for {
-              (rhs, actual) <- seenVars.toList
-              formal <- paramsOfLabel(plan.label).get(rhs)
-            }
-            yield (formal -> actual)
-          if (plan.args.isEmpty) { plan.args = newArgs; plan }
-          else if (newArgs == plan.args) plan
-          else CallPlan(plan.label, newArgs)
-        }
-      }
-      (new Merge(Map()))(plan)
-    }
-    */
-
     /** Inline let-bound trees that are referenced only once.
      *  Drop all variables that are not referenced anymore after this.
      */
@@ -782,6 +689,7 @@ object PatternMatcher {
         case _ => false
       }
 
+      // An extractor to recover the shape of plans that can become alternatives
       object AlternativesPlan {
         def unapply(plan: LabeledPlan): Option[(List[Tree], Plan)] = {
           plan.expr match {
@@ -951,7 +859,7 @@ object PatternMatcher {
             case ReturnPlan(label) =>
               sb.append(s"Return($label)")
             case SeqPlan(head, tail) =>
-              sb.append(s"${head.id}; ${tail.id}")
+              sb.append(s"Seq(${head.id}, ${tail.id})")
               showPlan(head)
               showPlan(tail)
             case ResultPlan(tree) =>
@@ -993,22 +901,16 @@ object PatternMatcher {
     val optimizations: List[(String, Plan => Plan)] = List(
       "mergeTests" -> mergeTests,
       "inlineVars" -> inlineVars
-      /*
-      "mergeVars" -> mergeVars,
-      "inlineVars" -> inlineVars
-      */
     )
 
     /** Translate pattern match to sequence of tests. */
     def translateMatch(tree: Match): Tree = {
       var plan = matchPlan(tree)
-      //patmatch.println(i"Plan for $tree: ${show(plan)}")
-      //System.err.println(i"Plan for $tree: ${show(plan)}")
+      patmatch.println(i"Plan for $tree: ${show(plan)}")
       if (!ctx.settings.YnoPatmatOpt.value)
         for ((title, optimization) <- optimizations) {
           plan = optimization(plan)
-          //patmatch.println(s"After $title: ${show(plan)}")
-          //System.err.println(s"After $title: ${show(plan)}")
+          patmatch.println(s"After $title: ${show(plan)}")
         }
       val result = emit(plan)
       checkSwitch(tree, result)