Unify patterns in UCS and UPS

hkmc2/shared/src/main/scala/hkmc2/semantics/Elaborator.scala

@@ -1431,9 +1431,19 @@ extends Importer with ucs.SplitElaborator:
      *  variables we found in `p`. */
     def arrow(lhs: Tree, rhs: Tree): Ctxl[Pattern] =
       val pattern = go(lhs)
-      val termCtx = ctx ++ pattern.variables.allocate
+      val variables = pattern.variables.allocate
+      // - `contextEntries` will be added to the context
+      // - `correspondence` is mapping from symbols representing variables
+      //   in the pattern to symbols for parameters to be used in the `term`.
+      val (contextEntries, correspondence) = variables.iterator.map:
+        case (name, symbol) =>
+          // We must create a symbol specifically for `Param` to avoid
+          // repetitively declare symbols in `Scope` during code generation.
+          val parameterSymbol = VarSymbol(new Ident(symbol.name))
+          (name -> parameterSymbol, symbol -> parameterSymbol)
+      .toList.unzip
       pattern.variables.report // Report all invalid variables we found in `pattern`.
-      Transform(pattern, term(rhs)(using termCtx))
+      Transform(pattern, correspondence, term(rhs)(using ctx ++ contextEntries))
     /** Elaborate tuple patterns like `[p1, p2, ...ps, pn]`. */
     def tuple(ts: Ls[Tree]): Ctxl[Pattern.Tuple] =
       // We are accumulating two components: the leading patterns, the spred

hkmc2/shared/src/main/scala/hkmc2/semantics/Pattern.scala

@@ -238,9 +238,13 @@ enum Pattern extends AutoLocated:
   case Alias(pattern: Pattern, id: Ident) extends Pattern with AliasImpl
 
   /** A pattern that matches the same value as other pattern, with an additional
-   *  function applied to the bound variables in the pattern.
+    * function applied to the bound variables in the pattern.
+    *
+    * @param pattern The pattern to be matched against.
+    * @param parameters A map from the variable symbols to parameter symbols.
+    * @param transform The term that should be applied to the extracted values.
    */
-  case Transform(pattern: Pattern, transform: Term)
+  case Transform(pattern: Pattern, parameters: Ls[(VarSymbol, VarSymbol)], transform: Term)
 
   case Annotated(pattern: Pattern, annotations: Vector[Term])
 
@@ -295,7 +299,7 @@ enum Pattern extends AutoLocated:
       case (name, pattern) => name :: pattern.children
     case Chain(first, second) => first :: second :: Nil
     case Alias(pattern, alias) => pattern :: alias :: Nil
-    case Transform(pattern, transform) => pattern :: transform :: Nil
+    case Transform(pattern, _, transform) => pattern :: transform :: Nil
     case Annotated(pattern, annotations) => pattern :: annotations.toList
     case Guarded(pattern, guard) => pattern.children :+ guard
 
@@ -311,7 +315,7 @@ enum Pattern extends AutoLocated:
     case Record(fields) => fields.flatMap(_._2.subTerms)
     case Chain(first, second) => first.subTerms ::: second.subTerms
     case Alias(pattern, _) => pattern.subTerms
-    case Transform(pattern, transform) => pattern.subTerms :+ transform
+    case Transform(pattern, _, transform) => pattern.subTerms :+ transform
     case Annotated(pattern, annotations) => pattern.subTerms ::: annotations.toList
     case Guarded(pattern, guard) => pattern.subTerms :+ guard
 
@@ -328,7 +332,7 @@ enum Pattern extends AutoLocated:
     case Record(_) => "record"
     case Chain(_, _) => "chain"
     case Alias(_, _) => "alias"
-    case Transform(_, _) => "transform"
+    case Transform(_, _, _) => "transform"
     case Annotated(_, _) => "annotated pattern"
     case Guarded(_, _) => "guarded pattern"
 
@@ -365,7 +369,7 @@ enum Pattern extends AutoLocated:
     case Chain(first, second) => s"${first.showDbgWithPar} as ${second.showDbgWithPar}"
     case Alias(Wildcard(), alias) => alias.name
     case Alias(pattern, alias) => s"${pattern.showDbgWithPar} as ${alias.name}"
-    case Transform(pattern, transform) => s"${pattern.showDbgWithPar} => ${transform.showDbg}"
+    case Transform(pattern, _, transform) => s"${pattern.showDbgWithPar} => ${transform.showDbg}"
     case Annotated(pattern, annotations) =>
       annotations.iterator.map(_.showDbg).mkString("@", " @", " ") + pattern.showDbgWithPar
     case Guarded(pattern, guard) => pattern.showDbg + " where " + guard.showDbg

hkmc2/shared/src/main/scala/hkmc2/semantics/ucs/Normalization.scala

@@ -603,38 +603,41 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
 
   /** Collect terms that appear in multiple `Split.Else` branches. We will share
    *  the corresponding blocks to avoid code duplication. */
-  private def collectSharedConsequents(split: Split): List[(Term, TempSymbol)] =
-    val counts: MutMap[Term, (Int, Int)] = MutMap.empty
+  private def createLabelsForDuplicatedBranches(split: Split): Labels =
+    val counts: MutMap[Term, (order: Int, count: Int)] = MutMap.empty
+    var throwCount = 0
     def rec(s: Split): Unit = s match
-      case Split.End => ()
+      case Split.End => throwCount += 1
       case Split.Else(els) => counts.updateWith(els):
         case S((n, count)) => S((n, count + 1))
         case N => S((counts.size + 1, 1))
       case Split.Let(_, _, tail) => rec(tail)
       case Split.Cons(Branch(_, _, cons), tail) => rec(cons); rec(tail)
     rec(split)
-    counts.iterator.filter(_._2._2 > 1).toSeq.sortBy(_._2._1).zipWithIndex.map:
-      case ((term, _), i) => (term, new TempSymbol(S(term), s"split_${i + 1}$$"))
-    .toList
+    val consequents =
+      counts.iterator.filter(_._2.count > 1).toSeq.sortBy(_._2.order).zipWithIndex.map:
+        case ((term, _), i) => (term, TempSymbol(S(term), s"split_${i + 1}$$"))
+      .toList
+    val default = if throwCount > 1 then S(TempSymbol(N, s"split_default$$")) else N
+    Labels(consequents, default)
 
   private def lowerSplit(
       split: Split,
-      sharedConsequents: Map[Term, TempSymbol],
       cont: (Result => Block) \/ (Bool => Result => Block),
       topLevel: Bool
-  )(using Subst): Block = split match
+  )(using labels: Labels)(using Subst): Block = split match
     case Split.Let(sym, trm, tl) =>
       term_nonTail(trm): r =>
-        Assign(sym, r, lowerSplit(tl, sharedConsequents, cont, topLevel))
+        Assign(sym, r, lowerSplit(tl, cont, topLevel))
     case Split.Cons(Branch(scrut, pat, tail), restSplit) =>
       subTerm_nonTail(scrut): sr =>
         tl.log(s"Binding scrut $scrut to $sr (${summon[Subst].map})") 
         def mkMatch(cse: Case -> Block) = Match(sr, cse :: Nil,
-            S(lowerSplit(restSplit, sharedConsequents, cont, topLevel = true)),
+            S(lowerSplit(restSplit, cont, topLevel = true)),
             End()
           )
         pat match
-          case FlatPattern.Lit(lit) => mkMatch(Case.Lit(lit) -> lowerSplit(tail, sharedConsequents, cont, topLevel = false))
+          case FlatPattern.Lit(lit) => mkMatch(Case.Lit(lit) -> lowerSplit(tail, cont, topLevel = false))
           case FlatPattern.ClassLike(ctor, argsOpt, _mode, _refined) =>
             /** Make a continuation that creates the match. */
             def k(ctorSym: ClassLikeSymbol, clsParams: Ls[TermSymbol])(st: Path): Block =
@@ -644,7 +647,7 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
               assert(argsOpt.isEmpty || args.length <= clsParams.length, (argsOpt, clsParams))
               def mkArgs(args: Ls[TermSymbol -> BlockLocalSymbol])(using Subst): Case -> Block = args match
                 case Nil =>
-                  Case.Cls(ctorSym, st) -> lowerSplit(tail, sharedConsequents, cont, topLevel = false)
+                  Case.Cls(ctorSym, st) -> lowerSplit(tail, cont, topLevel = false)
                 case (param, arg) :: args =>
                   val (cse, blk) = mkArgs(args)
                   (cse, Assign(arg, Select(sr, new Tree.Ident(param.id.name).withLocOf(arg))(S(param)), blk))
@@ -667,23 +670,25 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
                 // resolves to a class or module. Branches with unresolved
                 // constructors should have been removed.
                 lastWords("Pattern.ClassLike: constructor is neither a class nor a module")
-          case FlatPattern.Tuple(len, inf) => mkMatch(Case.Tup(len, inf) -> lowerSplit(tail, sharedConsequents, cont, topLevel = false))
+          case FlatPattern.Tuple(len, inf) => mkMatch(Case.Tup(len, inf) -> lowerSplit(tail, cont, topLevel = false))
           case FlatPattern.Record(entries) =>
             val objectSym = ctx.builtins.Object
             mkMatch( // checking that we have an object
               Case.Cls(objectSym, Value.Ref(BuiltinSymbol(objectSym.nme, false, false, true, false))),
-              entries.foldRight(lowerSplit(tail, sharedConsequents, cont, topLevel = false)):
+              entries.foldRight(lowerSplit(tail, cont, topLevel = false)):
                 case ((fieldName, fieldSymbol), blk) =>
                   mkMatch(
                     Case.Field(fieldName, safe = true), // we know we have an object, no need to check again
                     Assign(fieldSymbol, Select(sr, fieldName)(N), blk)
                   )
             )
-    case Split.Else(els) => sharedConsequents.get(els) match
+    case Split.Else(els) => labels.get(els) match
       case S(label) => Break(label)
       case N => term_nonTail(els)(cont.fold(identity, _(topLevel)))
-    case Split.End =>
-      Throw(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Error"))(N),
+    case Split.End => labels.default.fold(throwMatchErrorBlock)(Break(_))
+
+  private def throwMatchErrorBlock =
+    Throw(Instantiate(mut = false, Select(Value.Ref(State.globalThisSymbol), Tree.Ident("Error"))(N),
         Value.Lit(syntax.Tree.StrLit("match error")).asArg :: Nil)) // TODO add failed-match scrutinee info
 
   import syntax.Keyword.{`if`, `while`}
@@ -723,15 +728,15 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
     tl.scoped("ucs:normalized"):
       tl.log(s"Normalized:\n${normalized.prettyPrint}")
     // Collect consequents that are shared in more than one branch.
-    val sharedConsequents = collectSharedConsequents(normalized)
+    given labels: Labels = createLabelsForDuplicatedBranches(normalized)
     lazy val rootBreakLabel = new TempSymbol(N, "split_root$")
     lazy val breakRoot = (r: Result) => Assign(l, r, Break(rootBreakLabel))
     val cont =
       if kw === `while` then
         // If the term is a `while`, the action of `else` branches depends on
         // whether the the enclosing split is at the top level or not.
         R((topLevel: Bool) => (r: Result) => Assign(l, r, if topLevel then End() else Continue(loopLabel)))
-      else if sharedConsequents.isEmpty then
+      else if labels.isEmpty then
         if k.isInstanceOf[TailOp] then
           // If there are no shared consequents and the continuation is a tail
           // operation, we can call it directly.
@@ -749,34 +754,47 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
         L(breakRoot)
     // The main block contains the lowered split, where each shared consequent
     // is replaced with a `Break` to the corresponding label.
-    val mainBlock = lowerSplit(normalized, sharedConsequents.toMap, cont, topLevel = true)
-    // Wrap the main block in a labelled block for each shared consequent. The
-    // `rest` of each `Label` is the lowered consequent plus a `Break` to the
-    // end of the entire `if` term. Otherwise, it will fall through to the outer
-    // consequent, which is the wrong semantics.
-    val wrappedBlock = if sharedConsequents.isEmpty then mainBlock else
-      sharedConsequents.foldRight(mainBlock):
-        case ((term, label), innerBlock) =>
-          Label(label, false, innerBlock, term_nonTail(term)(breakRoot))
+    val mainBlock =
+      val innermostBlock = lowerSplit(normalized, cont, topLevel = true)
+      // Wrap the main block in a labelled block for each shared consequent. The
+      // `rest` of each `Label` is the lowered consequent plus a `Break` to the
+      // end of the entire `if` term. Otherwise, it will fall through to the outer
+      // consequent, which is the wrong semantics.
+      val innerBlock: Block = if labels.consequents.isEmpty then innermostBlock else
+        labels.consequents.foldRight(innermostBlock):
+          case ((term, label), innerBlock) =>
+            Label(label, false, innerBlock, term_nonTail(term)(breakRoot))
+      labels.default match
+        case S(label) => Label(label, false, innerBlock, throwMatchErrorBlock)
+        case N => innerBlock
     // If there are shared consequents, we need a wrap the entire block in a
     // `Label` so that `Break`s in the shared consequents can jump to the end.
-    val body = if sharedConsequents.isEmpty then wrappedBlock else
-      Label(rootBreakLabel, false, wrappedBlock, End())
+    val body = if labels.isEmpty then mainBlock else
+      Label(rootBreakLabel, false, mainBlock, End())
     // Embed the `body` into `Label` if the term is a `while`.
     lazy val rest = if usesResTmp then k(Value.Ref(l)) else k(lowering.unit)
-    val resultBlock =
+    val block =
       if kw === `while` then
         Begin(Label(loopLabel, true, body, End()), rest)
-      else if sharedConsequents.isEmpty && k.isInstanceOf[TailOp] then
+      else if labels.isEmpty && k.isInstanceOf[TailOp] then
         body
       else
         Begin(body, rest)
     scoped("ucs:lowered"):
-      log(s"Lowered:\n${resultBlock.showAsTree}")
-    resultBlock
+      log(s"Lowered:\n${block.showAsTree}")
+    block
 end Normalization
 
 object Normalization:
+  /** This contains the labels for duplicated consequents and the default
+   *  branch which throws match errors. */
+  private class Labels(val consequents: Ls[(Term, TempSymbol)], val default: Opt[TempSymbol]):
+    private val map = consequents.toMap
+
+    inline def isEmpty: Bool = consequents.isEmpty && default.isEmpty
+
+    inline def get(term: Term): Opt[TempSymbol] = map.get(term)
+
   /**
     * Hard-coded subtyping relations used in normalization and coverage checking.
     * TODO use base classes and also handle modules

hkmc2/shared/src/main/scala/hkmc2/semantics/ucs/SplitElaborator.scala

@@ -74,17 +74,19 @@ trait SplitElaborator:
   /** Elaborate shorthand expressions. */
   protected def shorthandSplit(tree: Tree)(using UnderCtx): Ctxl[SimpleSplit] =
     val affirmative = Else(Term.Lit(BoolLit(true)))
-    val split = tree match
-      case lhs is rhs => subterm(lhs).reference: scrut =>
-        val (firstPatternTree, _) :: matches = disaggregate(rhs)
-        val firstPattern = self.pattern(firstPatternTree)
-        // firstPattern.variables.report
-        (ctx ++ firstPattern.variables.allocate).givenIn:
-          val split = expandMatches(matches)(affirmative)
-          Head.Match(scrut(), firstPattern, split) ~: End
-      case matches =>
-        expandMatches(disaggregate(matches))(affirmative)
-    split ~~: Else(Term.Lit(BoolLit(false)))
+    val negative = Else(Term.Lit(BoolLit(false)))
+    val (scrutinee, pattern) :: matches = disaggregate(tree)
+    subterm(scrutinee).reference: scrutinee =>
+      lazy val innerSplit: Ctxl[SimpleSplit] = expandMatches(matches)(affirmative)
+      pattern match
+        case Block(trees) => trees.foldRight(negative):
+          case (pattern, alternative) =>
+            Head.Match(scrutinee(), self.pattern(pattern), innerSplit) ~: alternative
+        case _ =>
+          val firstPattern = self.pattern(pattern)
+          firstPattern.variables.report
+          (ctx ++ firstPattern.variables.allocate).givenIn:
+            Head.Match(scrutinee(), firstPattern, innerSplit) ~: negative
 
   /** Desugar a list of trees as a term split. The returned function takes a
     * function, which takes a `Ctx` and returns a `SimpleSplit` representing

hkmc2/shared/src/main/scala/hkmc2/semantics/ups/Compiler.scala

@@ -347,17 +347,20 @@ class Compiler(using Context)(using tl: TL)(using Ctx, State, Raise) extends Ter
     case Rename(pattern, name) =>
       // We should add those fields to a context.
       completePattern(pattern, scrutinee, subScrutinees, name :: aliases)
-    case Extract(pattern, term) =>
+    case Extract(pattern, correspondence, term) =>
       // The symbol representing the transform function, which should be
       // declared at the outermost level.
       val transformSymbol = TempSymbol(N, "transform")
       // The transform function takes a single record as the argument.
       val bindingsSymbol = VarSymbol(Ident("args"))
       val params = paramList(param(bindingsSymbol))
-      // We then bind the variables to fields of the record.
+      // Because we pass the extracted values using recoreds. We need to bind
+      // each property to its corresponding variable which is accessible from
+      // then `term`.
       val letBindings = pattern.symbols.flatMap: symbol =>
-        LetDecl(symbol, Nil) ::
-        DefineVar(symbol, sel(bindingsSymbol.safeRef, symbol.name)) :: Nil
+        val termSymbol = correspondence(symbol)
+        LetDecl(termSymbol, Nil) ::
+        DefineVar(termSymbol, sel(bindingsSymbol.safeRef, termSymbol.name)) :: Nil
       val makeSplit = completePattern(pattern, scrutinee, subScrutinees, Nil)
       (makeConsequent, alternative) => Split.Let(
         sym = transformSymbol,

hkmc2/shared/src/main/scala/hkmc2/semantics/ups/Instantiator.scala

@@ -69,10 +69,10 @@ class Instantiator(using tl: TL)(using Ctx, State, Raise):
         progress += (instantiation -> S(instantiated))
     // Finally, return the synonym representing the entry point pattern and all
     // instantiated pattern definitions.
-    Context:
-      progress.view.mapValues:
-        _.getOrElse(lastWords("The pattern is expected to be instantiated."))
-      .toMap
+    val definitions = progress.view.mapValues:
+      _.getOrElse(lastWords("The pattern is expected to be instantiated."))
+    .toMap
+    new Context(definitions)
 
   /** Add the instantiation to the queue if it has not been instantiated yet. */
   def schedule(instantiation: Instantiation): Instantiation =
@@ -159,4 +159,5 @@ class Instantiator(using tl: TL)(using Ctx, State, Raise):
       case N => instantiate(pattern)
       case S(symbol) => Rename(instantiate(pattern), symbol)
     // Pattern arguments are accessible throughout the pattern.
-    case SP.Transform(pattern, transform) => Extract(instantiate(pattern), transform)
+    case SP.Transform(pattern, parameters, transform) =>
+      Extract(instantiate(pattern), parameters.toMap, transform)