Improvements and fixes for UCS

shared/src/main/scala/mlscript/Typer.scala

@@ -1047,9 +1047,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool)
       case iff @ If(body, fallback) =>
         import mlscript.ucs._
         try {
-          val caseTree = MutCaseOf.build(desugarIf(body, fallback))
-          println("The mutable CaseOf tree")
-          MutCaseOf.show(caseTree).foreach(println(_))
+          val caseTree = buildCaseTree(desugarIf(body, fallback))
           checkExhaustive(caseTree, N)(summarizePatterns(caseTree), ctx, raise)
           val desugared = constructTerm(caseTree)
           println(s"Desugared term: ${desugared.print(false)}")

shared/src/main/scala/mlscript/ucs/Clause.scala

@@ -23,7 +23,10 @@ abstract class Clause {
   val locations: Ls[Loc]
 
   protected final def bindingsToString: String =
-    (if (bindings.isEmpty) "" else " with " + Clause.showBindings(bindings))
+    if (bindings.isEmpty) "" else " with " + (bindings match {
+      case Nil => ""
+      case bindings => bindings.map(_.name.name).mkString("(", ", ", ")")
+    })
 }
 
 object Clause {
@@ -64,23 +67,4 @@ object Clause {
   ) extends Clause {
     override def toString(): String = s"«$name = $term»" + bindingsToString
   }
-
-  def showBindings(bindings: Ls[LetBinding]): Str =
-    bindings match {
-      case Nil => ""
-      case bindings => bindings.map(_.name.name).mkString("(", ", ", ")")
-    }
-
-  def showClauses(clauses: Iterable[Clause]): Str = clauses.mkString("", " and ", "")
-
-  def print(println: (=> Any) => Unit, conjunctions: Iterable[Conjunction -> Term]): Unit = {
-    println("Flattened conjunctions")
-    conjunctions.foreach { case Conjunction(clauses, trailingBindings) -> term =>
-      println("+ " + showClauses(clauses) + {
-        (if (trailingBindings.isEmpty) "" else " ") +
-          showBindings(trailingBindings) +
-          s" => $term"
-      })
-    }
-  }
 }

shared/src/main/scala/mlscript/ucs/Desugarer.scala

@@ -273,7 +273,7 @@ class Desugarer extends TypeDefs { self: Typer =>
       // What else?
       case _ => throw new DesugaringException(msg"illegal pattern", pattern.toLoc)
     }
-  }("[Desugarer.destructPattern] result: " + Clause.showClauses(_))
+  }("[Desugarer.destructPattern] Result: " + _.mkString(", "))
 
   /**
     * Collect `Loc`s from a synthetic term.
@@ -363,7 +363,7 @@ class Desugarer extends TypeDefs { self: Typer =>
           val (patternPart, extraTestOpt) = separatePattern(patTest)
           val clauses = destructPattern(scrutinee, partialPattern.addTerm(patternPart).term, true)
           val conditions = collectedConditions + Conjunction(clauses, Nil).withBindings
-          printlnUCS(s"result conditions: " + Clause.showClauses(conditions.clauses))
+          printlnUCS(s"Result: " + conditions.clauses.mkString(", "))
           extraTestOpt match {
             // Case 1. Just a pattern. Easy!
             case N => 
@@ -517,9 +517,19 @@ class Desugarer extends TypeDefs { self: Typer =>
     desugarIfBody(body, PartialTerm.Empty, Conjunction.empty)(interleavedLets)
     // Add the fallback case to conjunctions if there is any.
     fallback.foreach { branches += Conjunction.empty -> _ }
-    Clause.print(printlnUCS, branches)
+    printlnUCS("Decision paths:")
+    branches.foreach { case Conjunction(clauses, trailingBindings) -> term =>
+      printlnUCS("+ " + clauses.mkString("", " and ", "") + {
+        (if (trailingBindings.isEmpty) "" else " ") +
+          (trailingBindings match {
+            case Nil => ""
+            case bindings => bindings.map(_.name.name).mkString("(", ", ", ")")
+          }) +
+          s" => $term"
+      })
+    }
     branches.toList
-  }(r => s"[desugarIf] produces ${r.size} branch(es)")
+  }(r => s"[desugarIf] produces ${r.size} ${"path".pluralize(r.size)}")
 
   import MutCaseOf.{MutCase, IfThenElse, Match, MissingCase, Consequent}
 
@@ -718,22 +728,36 @@ class Desugarer extends TypeDefs { self: Typer =>
       m match {
         case Consequent(term) => term
         case Match(scrutinee, branches, wildcard) =>
+          printlnUCS("• Owned let bindings")
+          val ownedBindings = m.getBindings.iterator.filterNot {
+            _.kind === LetBinding.Kind.InterleavedLet
+          }.toList
+          if (ownedBindings.isEmpty)
+            printlnUCS("  * <No bindings>")
+          else
+            ownedBindings.foreach { case LetBinding(kind, _, name, value) =>
+              printlnUCS(s"  * ($kind) $name = $value")
+            }
+          // Collect interleaved let bindings from case branches.
+          // Because they should be declared before 
+          val interleavedBindings = branches.iterator.map(_.consequent).concat(wildcard).flatMap(_.getBindings).filter {
+            _.kind === LetBinding.Kind.InterleavedLet
+          }.toList
+          printlnUCS("• Collect interleaved let bindings from case branches")
+          if (interleavedBindings.isEmpty)
+            printlnUCS("  * <No interleaved bindings>")
+          else
+            interleavedBindings.foreach { case LetBinding(_, _, name, value) =>
+              printlnUCS(s"  * $name = $value")
+            }
           val cases = traceUCS("• For each case branch"){
             rec2(branches.toList)(defs, scrutinee, wildcard)
           }(_ => "• End for each")
           val resultTerm = scrutinee.local match {
             case N => CaseOf(scrutinee.term, cases)
             case S(aliasVar) => Let(false, aliasVar, scrutinee.term, CaseOf(aliasVar, cases))
           }
-          // Collect interleaved let bindings from case branches.
-          val bindings = branches.iterator.flatMap(_.consequent.getBindings).filter {
-            _.kind === LetBinding.Kind.InterleavedLet
-          }.toList
-          printlnUCS("• Collect interleaved let bindings from case branches")
-          bindings.foreach { case LetBinding(_, _, name, value) =>
-            printlnUCS(s"  - $name = $value")
-          }
-          mkBindings(bindings, resultTerm, defs)
+          mkBindings(ownedBindings, mkBindings(interleavedBindings, resultTerm, defs), defs)
         case MissingCase =>
           import Message.MessageContext
           throw new DesugaringException(msg"missing a default branch", N)
@@ -790,4 +814,25 @@ class Desugarer extends TypeDefs { self: Typer =>
       }
     rec(scrutinee.reference, fields)
   }
+
+  protected def buildCaseTree
+    (paths: Ls[Conjunction -> Term])
+    (implicit raise: Diagnostic => Unit)
+  : MutCaseOf = traceUCS("[buildCaseTree]") {
+    paths match {
+      case Nil => MissingCase
+      case (conditions -> term) :: remaining =>
+        val root = MutCaseOf.buildFirst(conditions, term)
+        traceUCS("*** Initial tree ***") {
+          MutCaseOf.show(root).foreach(printlnUCS(_))
+        }()
+        remaining.foreach { path =>
+          root.merge(path)
+          traceUCS("*** Updated tree ***") {
+            MutCaseOf.show(root).foreach(printlnUCS(_))
+          }()
+        }
+        root
+    }
+  }(_ => "[buildCaseTree]")
 }

shared/src/main/scala/mlscript/ucs/LetBinding.scala

@@ -12,9 +12,15 @@ object LetBinding {
   sealed abstract class Kind
 
   object Kind {
-    case object ScrutineeAlias extends Kind
-    case object FieldExtraction extends Kind
-    case object InterleavedLet extends Kind
+    case object ScrutineeAlias extends Kind {
+      override def toString(): String = "scrutinee alias"
+    }
+    case object FieldExtraction extends Kind {
+      override def toString(): String = "pattern destruction"
+    }
+    case object InterleavedLet extends Kind {
+      override def toString(): String = "interleaved let"
+    }
   }
 }
 

shared/src/main/scala/mlscript/ucs/MutCaseOf.scala

@@ -43,44 +43,50 @@ object MutCaseOf {
 
   def show(t: MutCaseOf): Ls[Str] = {
     val lines = Buffer.empty[String]
-    def rec(t: MutCaseOf, indent: Int, leading: String): Unit = {
+    def rec(t: MutCaseOf, indent: Int): Unit = {
       val baseIndent = "  " * indent
-      val bindingNames = t.getBindings match {
-        case Nil => ""
-        case bindings => bindings.iterator.map(_.name.name).mkString("[", ", ", "] ")
-      }
+      lazy val bindingLines = t.getBindings.iterator.map {
+        case LetBinding(_, recursive, name, term) =>
+          // Show bindings
+          s"[binding $name = $term]"
+      }.toList
       t match {
         case IfThenElse(condition, whenTrue, whenFalse) =>
           // Output the `whenTrue` with the prefix "if".
-          lines += baseIndent + leading + bindingNames + s"if «$condition»"
-          rec(whenTrue, indent + 1, "")
+          bindingLines.foreach { lines += baseIndent + _ }
+          lines += baseIndent + s"if «$condition»"
+          rec(whenTrue, indent + 1)
           // Output the `whenFalse` case with the prefix "else".
-          lines += s"$baseIndent${leading}else"
-          rec(whenFalse, indent + 1, "")
+          lines += s"${baseIndent}else"
+          rec(whenFalse, indent + 1)
         case Match(scrutinee, branches, default) =>
-          lines += baseIndent + leading + bindingNames + showScrutinee(scrutinee) + " match"
+          bindingLines.foreach { lines += baseIndent + _ }
+          lines += baseIndent + showScrutinee(scrutinee) + " match"
           branches.foreach {
             case MutCase.Literal(literal, consequent) =>
               lines += s"$baseIndent  case $literal =>"
-              rec(consequent, indent + 1, "")
+              rec(consequent, indent + 1)
             case MutCase.Constructor(Var(className) -> fields, consequent) =>
               lines += s"$baseIndent  case $className =>"
               fields.foreach { case (field, Var(alias)) =>
-                lines += s"$baseIndent    let $alias = .$field"
+                // Show pattern bindings.
+                lines += s"$baseIndent    [pattern $alias = ${scrutinee.reference}.$field]"
               }
-              rec(consequent, indent + 2, "")
+              rec(consequent, indent + 2)
           }
           default.foreach { consequent =>
             lines += s"$baseIndent  default"
-            rec(consequent, indent + 2, "")
+            rec(consequent, indent + 2)
           }
         case Consequent(term) =>
-          lines += s"$baseIndent$leading$bindingNames«$term»"
+          bindingLines.foreach { lines += baseIndent + _ }
+          lines += s"$baseIndent«$term»"
         case MissingCase =>
-          lines += s"$baseIndent$leading$bindingNames<missing case>"
+          bindingLines.foreach { lines += baseIndent + _ }
+          lines += s"$baseIndent<missing case>"
       }
     }
-    rec(t, 0, "")
+    rec(t, 0)
     lines.toList
   }
 
@@ -217,7 +223,16 @@ object MutCaseOf {
       })"
     }
 
-    def merge(branch: Conjunction -> Term)(implicit raise: Diagnostic => Unit): Unit = {
+    def merge(originalBranch: Conjunction -> Term)(implicit raise: Diagnostic => Unit): Unit = {
+      // Remove let bindings that already has been declared.
+      val branch = originalBranch._1.copy(clauses = originalBranch._1.clauses.filter {
+        case Binding(name, value, false) if (getBindings.exists {
+          case LetBinding(LetBinding.Kind.ScrutineeAlias, _, n, v) =>
+            n === name && v === value
+          case _ => false
+        }) => false
+        case _ => true
+      }) -> originalBranch._2
       branch._1.separate(scrutinee) match {
         // No conditions against the same scrutinee.
         case N =>
@@ -331,53 +346,51 @@ object MutCaseOf {
     def mergeDefault(bindings: Ls[LetBinding], default: Term)(implicit raise: Diagnostic => Unit): Int = 0
   }
 
-  private def buildFirst(conjunction: Conjunction, term: Term): MutCaseOf = {
+  def buildFirst(conjunction: Conjunction, term: Term): MutCaseOf = {
     def rec(conjunction: Conjunction): MutCaseOf = conjunction match {
       case Conjunction(head :: tail, trailingBindings) =>
-        val realTail = Conjunction(tail, trailingBindings)
+        lazy val (beforeHeadBindings, afterHeadBindings) = head.bindings.partition {
+          case LetBinding(LetBinding.Kind.InterleavedLet, _, _, _) => false
+          case LetBinding(_, _, _, _) => true
+        }
+        val consequentTree = rec(Conjunction(tail, trailingBindings))
         (head match {
           case MatchLiteral(scrutinee, literal) =>
             val branches = Buffer(
-              MutCase.Literal(literal, rec(realTail)).withLocation(literal.toLoc)
+              MutCase.Literal(literal, consequentTree.withBindings(afterHeadBindings)).withLocation(literal.toLoc)
             )
             Match(scrutinee, branches, N)
-          case BooleanTest(test) => IfThenElse(test, rec(realTail), MissingCase)
+              .withBindings(beforeHeadBindings)
+          case BooleanTest(test) =>
+            IfThenElse(test, consequentTree, MissingCase)
+              .withBindings(beforeHeadBindings)
+              .withBindings(afterHeadBindings)
           case MatchClass(scrutinee, className, fields) =>
             val branches = Buffer(
-              MutCase.Constructor(className -> Buffer.from(fields), rec(realTail))
+              MutCase.Constructor(className -> Buffer.from(fields), consequentTree.withBindings(afterHeadBindings))
                 .withLocations(head.locations)
             )
-            Match(scrutinee, branches, N)
+            Match(scrutinee, branches, N).withBindings(beforeHeadBindings)
           case MatchTuple(scrutinee, arity, fields) =>
             val branches = Buffer(
-              MutCase.Constructor(Var(s"Tuple#$arity") -> Buffer.from(fields), rec(realTail))
+              MutCase.Constructor(Var(s"Tuple#$arity") -> Buffer.from(fields), consequentTree.withBindings(afterHeadBindings))
                 .withLocations(head.locations)
             )
-            Match(scrutinee, branches, N)
+            Match(scrutinee, branches, N).withBindings(beforeHeadBindings)
           case Binding(name, term, isField) =>
             val kind = if (isField)
               LetBinding.Kind.FieldExtraction
             else
               LetBinding.Kind.ScrutineeAlias
-            rec(realTail).withBindings(LetBinding(kind, false, name, term) :: Nil)
-        }).withBindings(head.bindings)
+            consequentTree
+              .withBindings(beforeHeadBindings)
+              .withBindings(LetBinding(kind, false, name, term) :: Nil)
+              .withBindings(afterHeadBindings)
+        })
       case Conjunction(Nil, trailingBindings) =>
         Consequent(term).withBindings(trailingBindings)
     }
 
     rec(conjunction)
   }
-
-  def build
-    (cnf: Ls[Conjunction -> Term])
-    (implicit raise: Diagnostic => Unit)
-  : MutCaseOf = {
-    cnf match {
-      case Nil => MissingCase
-      case (conditions -> term) :: next =>
-        val root = MutCaseOf.buildFirst(conditions, term)
-        next.foreach(root.merge(_))
-        root
-    }
-  }
 }