Support fixed-length tuple patterns

# Conflicts:
#	hkmc2/shared/src/test/mlscript/ucs/patterns/SimpleTuple.mls

Author: chengluyu

hkmc2/shared/src/main/scala/hkmc2/codegen/Block.scala

@@ -100,6 +100,7 @@ case class End(msg: Str = "") extends BlockTail with ProductWithTail
 enum Case:
   case Lit(lit: Literal)
   case Cls(cls: ClassSymbol)
+  case Tup(len: Int)
 
 sealed abstract class Result
 

hkmc2/shared/src/main/scala/hkmc2/codegen/Lowering.scala

@@ -245,6 +245,11 @@ class Lowering(using TL, Raise, Elaborator.State):
                     val (cse, blk) = mkArgs(args)
                     (cse, Assign(arg, Select(sr, param.sym.id/*FIXME incorrect Ident?*/), blk))
                 mkArgs(clsParams.zip(args))
+              case Pattern.Tuple(args) =>
+                val cse = Case.Tup(args.length) -> go(tail, topLevel = false)
+                val blk = args.iterator.zipWithIndex.foldRight[Block](cse._2):
+                  case ((f, i), acc) => Assign(f, Select(sr, Tree.Ident(s"$i")), acc)
+                (cse._1, blk)
             Match(sr, cse :: Nil,
               S(go(restSplit, topLevel = true)),
               End()

hkmc2/shared/src/main/scala/hkmc2/codegen/js/JSBuilder.scala

@@ -193,6 +193,16 @@ class JSBuilder extends CodeBuilder:
         doc" else { #{ ${ returningTerm(el) } #}  # }"
       case N  => doc""
       t :: e :: returningTerm(rest)
+    case Match(scrut, Case.Tup(len) -> trm :: Nil, els, rest) =>
+      val test = doc"Array.isArray(${ result(scrut) }) && ${ result(scrut) }.length === ${len}"
+      val t = doc" # if (${ test }) { #{ ${
+          returningTerm(trm)
+        } #}  # }"
+      val e = els match
+      case S(el) =>
+        doc" else { #{ ${ returningTerm(el) } #}  # }"
+      case N  => doc""
+      t :: e :: returningTerm(rest)
 
     case Begin(sub, thn) =>
       doc"${returningTerm(sub)} # ${returningTerm(thn).stripBreaks}"

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

@@ -7,6 +7,7 @@ import Message.MessageContext
 import utils.TraceLogger
 import hkmc2.syntax.Literal
 import Keyword.{as, and, `else`, is, let, `then`}
+import collection.mutable.HashMap
 
 object Desugarer:
   extension (op: Keyword.Infix)
@@ -20,6 +21,10 @@ object Desugarer:
       case lhs and rhs => S((lhs, L(rhs)))
       case lhs `then` rhs => S((lhs, R(rhs)))
       case _ => N
+
+  class ScrutineeData:
+    val classes: HashMap[ClassSymbol, List[BlockLocalSymbol]] = HashMap.empty
+    val tuples: HashMap[Int, List[BlockLocalSymbol]] = HashMap.empty
 end Desugarer
 
 class Desugarer(tl: TraceLogger, elaborator: Elaborator)(using raise: Raise, state: Elaborator.State):
@@ -57,16 +62,18 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)(using raise: Raise, sta
         case Split.Let(name, term, tail) => Split.Let(name, term, tail ++ fallback)
         case Split.Else(_) /* impossible */ | Split.End => fallback)
 
-  import collection.mutable.HashMap
-
-  private val subScrutineeMap = HashMap.empty[BlockLocalSymbol, HashMap[ClassSymbol, List[BlockLocalSymbol]]]
+  private val subScrutineeMap = HashMap.empty[BlockLocalSymbol, ScrutineeData]
 
   extension (symbol: BlockLocalSymbol)
     def getSubScrutinees(cls: ClassSymbol): List[BlockLocalSymbol] =
-      subScrutineeMap.getOrElseUpdate(symbol, HashMap.empty).getOrElseUpdate(cls, {
+      subScrutineeMap.getOrElseUpdate(symbol, new ScrutineeData).classes.getOrElseUpdate(cls, {
         val arity = cls.defn.flatMap(_.paramsOpt.map(_.length)).getOrElse(0)
         (0 until arity).map(i => TempSymbol(nextUid, N, s"param$i")).toList
       })
+    def getSubScrutinees(arity: Int): List[BlockLocalSymbol] =
+      subScrutineeMap.getOrElseUpdate(symbol, new ScrutineeData).tuples.getOrElseUpdate(arity, {
+        (0 until arity).map(i => TempSymbol(nextUid, N, s"elem$i")).toList
+      })
 
   def default: Split => Sequel = split => _ => split
 
@@ -388,6 +395,16 @@ class Desugarer(tl: TraceLogger, elaborator: Elaborator)(using raise: Raise, sta
           // Raise an error and discard `sequel`. Use `fallback` instead.
           raise(ErrorReport(msg"Unknown symbol `${ctor.name}`." -> ctor.toLoc :: Nil))
           fallback
+      case Tree.Tup(args) => fallback => ctx => trace(
+        pre = s"expandMatch <<< ${args.mkString(", ")}",
+        post = (r: Split) => s"expandMatch >>> ${r.showDbg}"
+      ):
+        val params = scrutSymbol.getSubScrutinees(args.length)
+        Branch(
+          ref,
+          Pattern.Tuple(params),
+          subMatches(params zip args, sequel)(Split.End)(ctx)
+        ) ~: fallback
       // A single constructor pattern.
       case pat @ App(ctor: Ident, Tup(args)) => fallback => ctx => trace(
         pre = s"expandMatch <<< ${ctor.name}(${args.iterator.map(_.showDbg).mkString(", ")})",

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

@@ -591,14 +591,14 @@ extends Importer:
       case id @ Ident(name) =>
         val sym = boundVars.getOrElseUpdate(name, VarSymbol(id, nextUid))
         Pattern.Var(sym)
-      case Tup(fields) =>
-        val pats = fields.map(
-          f => pattern(f) match
-            case (pat, vars) =>
-              boundVars ++= vars
-              pat
-        )
-        Pattern.Tuple(pats)
+      // case Tup(fields) =>
+      //   val pats = fields.map(
+      //     f => pattern(f) match
+      //       case (pat, vars) =>
+      //         boundVars ++= vars
+      //         pat
+      //   )
+      //   Pattern.Tuple(pats)
       case _ =>
         ???
     (go(t), boundVars.toList)

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

@@ -2,36 +2,40 @@ package hkmc2
 package semantics
 
 import mlscript.utils.*, shorthands.*
-import syntax.*
+import syntax.*, Tree.Ident
 
 
-enum Pattern extends Located:
+enum Pattern extends AutoLocated:
   case Lit(literal: Literal)
-  case Var(nme: BlockLocalSymbol)
-  case Class(nme: ClassSymbol, parameters: Opt[List[BlockLocalSymbol]], var refined: Bool)(val ident: Tree.Ident)
-  case Tuple(fields: List[Pattern])
-  case Record(entries: List[(VarSymbol -> Pattern)])
+  case Var(sym: BlockLocalSymbol)
+  case Class(sym: ClassSymbol, params: Opt[List[BlockLocalSymbol]], var refined: Bool)(val ident: Ident)
+  case Tuple(fields: List[BlockLocalSymbol])
+  case Record(entries: List[(Ident -> BlockLocalSymbol)])
 
-  def toLoc: Opt[Loc] = this match
-    case Lit(literal) => literal.toLoc
-    case pat @ Class(_, _, _) => pat.ident.toLoc
+  protected def children: List[Located] =
+    this match
+      case Lit(literal) => literal :: Nil
+      case Var(sym) => sym :: Nil
+      case Class(sym, params, _) => sym :: params.getOrElse(Nil)
+      case Tuple(fields) => fields
+      case Record(entries) => entries.flatMap:
+        (key, pat) => key :: pat :: Nil
 
   def subTerms: Ls[Term] = this match
-    case Lit(literal) => Nil
-    case Var(nme) => Nil
-    case Class(_, parameters, _) => Nil
-    case Tuple(fields) => fields.flatMap(_.subTerms)
-    case Record(entries) => entries.flatMap(_._2.subTerms)
+    case Lit(_) => Nil
+    case Var(_) => Nil
+    case Class(_, _, _) => Nil
+    case Tuple(_) => Nil
+    case Record(_) => Nil
 
   def showDbg: Str = this match
     case Lit(literal) => literal.idStr
-    case Var(nme) => nme.toString
-    case Class(sym, ps, rfd) => (if rfd then "refined " else "") + (ps match {
-      case N => sym.nme
-      case S(parameters) => parameters.mkString(s"${sym.nme}(", ", ", ")")
-    })
-    case Tuple(fields) => fields.mkString("(", ", ", ")")
+    case Var(sym) => sym.nme
+    case Class(sym, ps, rfd) => (if rfd then "refined " else "") +
+      sym.nme + ps.fold("")(_.mkString("(", ", ", ")"))
+    case Tuple(fields) => fields.mkString("[", ", ", "]")
     case Record(Nil) => "{}"
-    case Record(entries) => entries.iterator.map { case (nme, als) => s"$nme: $als" }.mkString("{ ", ", ", " }")
+    case Record(entries) =>
+      entries.iterator.map(_.name + ": " + _).mkString("{ ", ", ", " }")
 
 

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

@@ -47,6 +47,7 @@ class Normalization(tl: TraceLogger)(using raise: Raise):
     def =:=(rhs: Pattern): Bool = (lhs, rhs) match
       case (Pattern.Class(s1, _, _), Pattern.Class(s2, _, _)) => s1 === s2
       case (Pattern.Lit(l1), Pattern.Lit(l2)) => l1 === l2
+      case (Pattern.Tuple(fs1), Pattern.Tuple(fs2)) => fs1.length === fs2.length
       case (_, _) => false
     /** Checks if `self` can be subsumed under `rhs`. */
     def <:<(rhs: Pattern): Bool =
@@ -89,7 +90,7 @@ class Normalization(tl: TraceLogger)(using raise: Raise):
         case Pattern.Var(vs) =>
           log(s"ALIAS: $scrutinee is $vs")
           Split.Let(vs, scrutinee, rec(consequent ++ alternative))
-        case pattern @ (Pattern.Lit(_) | Pattern.Class(_, _, _)) =>
+        case pattern @ (Pattern.Lit(_) | Pattern.Class(_, _, _) | Pattern.Tuple(_)) =>
           log(s"MATCH: $scrutinee is $pattern")
           val whenTrue = normalize(specialize(consequent ++ alternative, +, scrutinee, pattern))
           val whenFalse = rec(specialize(alternative, -, scrutinee, pattern).clearFallback)
@@ -145,7 +146,7 @@ class Normalization(tl: TraceLogger)(using raise: Raise):
                   log(s"Case 1.1.1: $pattern =:= $thatPattern")
                   thatPattern reportInconsistentRefinedWith pattern
                   aliasBindings(pattern, thatPattern)(rec(continuation) ++ rec(tail))
-                else if (thatPattern <:< pattern) then
+                else if thatPattern <:< pattern then
                   log(s"Case 1.1.2: $pattern <:< $thatPattern")
                   pattern.markAsRefined; split
                 else if split.isFallback then

hkmc2/shared/src/test/mlscript/codegen/BadIdent.mls

@@ -0,0 +1,14 @@
+:js
+:sjs
+
+let x = 0
+//│ JS:
+//│ this.x = 0; undefined
+//│ x = 0
+
+:fixme
+let x' = 0
+//│ JS:
+//│ this.x' = 0; undefined
+//│ ═══[COMPILATION ERROR] [Uncaught SyntaxError] Unexpected string
+//│ ═══[COMPILATION ERROR] [Uncaught SyntaxError] Unexpected string

hkmc2/shared/src/test/mlscript/ucs/general/DualOptions.mls

@@ -103,25 +103,12 @@ add_5(None, Some(9))
 add_5(Some(5), Some(9))
 
 
-:fixme
 fun add_6(x, y) =
   if [x, y] is
     [Some(xv), Some(yv)] then xv + yv
     [Some(xv), None]     then xv
     [None,     Some(yv)] then yv
     [None,     None]     then 0
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.112: 	    [None,     None]     then 0
-//│ ╙──       	    ^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.111: 	    [None,     Some(yv)] then yv
-//│ ╙──       	    ^^^^^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.110: 	    [Some(xv), None]     then xv
-//│ ╙──       	    ^^^^^^^^^^^^^^^^
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.109: 	    [Some(xv), Some(yv)] then xv + yv
-//│ ╙──       	    ^^^^^^^^^^^^^^^^^^^^
 
 add_6(None, None)
 add_6(Some(5), None)

hkmc2/shared/src/test/mlscript/ucs/patterns/SimpleTuple.mls

@@ -5,72 +5,79 @@ fun sum(x, y) = x + y
 sum(1, 2)
 
 :fixme
-fun sum'([x, y]) = x + y
-sum'([1, 2])
+fun sum([x, y]) = x + y
+sum([1, 2])
 //│ /!!!\ Uncaught error: scala.MatchError: Tup(List(Ident(x), Ident(y))) (of class hkmc2.syntax.Tree$Tup)
 
-:todo
+:ucs desugared
 fun sum''(pair) =
   if pair is [x, y] then x + y
 sum''([1, 2])
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.14: 	  if pair is [x, y] then x + y
-//│ ╙──      	             ^^^^^^
-
-// We need native support for tuple patterns in MLscript syntax.
-// Otherwise the following cases work.
+//│ Desugared:
+//│ >  if pair@31 is [$elem0@32, $elem1@33] and
+//│ >    let x@34 = $elem0@32#0
+//│ >    let y@35 = $elem1@33#0
+//│ >    else .+#1(x@34#0, y@35#0)
 
-:todo
+:ucs desugared
 fun test(thing) =
   if thing is [] then 0
 test("")
 test(12)
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.25: 	  if thing is [] then 0
-//│ ╙──      	              ^^
+//│ Desugared:
+//│ >  if thing@40 is [] then 0
 
-:todo
-// Since pattern destruction is desugared to let bindings, matching with other
-// classes after the tuple pattern will not work.
+:ucs desugared
 class Point(x: Int, y: Int)
 fun discarded_cases(thing) =
   if thing is
     [x, y] then x + y
     Point(x, y) then x + y
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.38: 	    [x, y] then x + y
-//│ ╙──      	    ^^^^^^
+//│ Desugared:
+//│ >  if
+//│ >    thing@45 is [$elem0@51, $elem1@52] and
+//│ >      let x@53 = $elem0@51#0
+//│ >      let y@54 = $elem1@52#0
+//│ >      else .+#3(x@53#0, y@54#0)
+//│ >    thing@45 is Point($param0@46, $param1@47) and
+//│ >      let x@48 = $param0@46#0
+//│ >      let y@49 = $param1@47#0
+//│ >      else .+#2(x@48#0, y@49#0)
 
 :e
 :todo
 discarded_cases(Point(0, 0))
 
 // A workaround is to move the tuple pattern to the last case.
-:todo
+:ucs desugared
 fun working_cases(thing) =
   if thing is
     Point(x, y) then x + y
     [x, y] then x + y
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.53: 	    [x, y] then x + y
-//│ ╙──      	    ^^^^^^
+//│ Desugared:
+//│ >  if
+//│ >    thing@61 is Point($param0@67, $param1@68) and
+//│ >      let x@69 = $param0@67#0
+//│ >      let y@70 = $param1@68#0
+//│ >      else .+#5(x@69#0, y@70#0)
+//│ >    thing@61 is [$elem0@62, $elem1@63] and
+//│ >      let x@64 = $elem0@62#0
+//│ >      let y@65 = $elem1@63#0
+//│ >      else .+#4(x@64#0, y@65#0)
 
 working_cases(Point(0, 0))
 
 // However, the `Object` type forbids tuples to be used.
 :todo
 working_cases([0, 0])
 
-:todo
+
 fun not_working(x) =
   if x is
     [a, b, c] then
       a + b + c
     else
       0
-//│ ╔══[ERROR] Unrecognized pattern.
-//│ ║  l.67: 	    [a, b, c] then
-//│ ╙──      	    ^^^^^^^^^
 
 not_working([1, 2, 3])