Record patterns, conjunction, disjunction added to ucs (#306)

Co-authored-by: Florent Ferrari <[email protected]>
Co-authored-by: Luyu Cheng <[email protected]>
Co-authored-by: Lionel Parreaux <[email protected]>

Author: 3 people

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

@@ -393,16 +393,22 @@ enum Case:
   case Lit(lit: Literal)
   case Cls(cls: ClassLikeSymbol, path: Path)
   case Tup(len: Int, inf: Bool)
+  /** checks field existence
+    * @param safe true will omit the instanceof Object check
+  */
+  case Field(name: Tree.Ident, safe: Bool)
 
   lazy val freeVars: Set[Local] = this match
     case Lit(_) => Set.empty
     case Cls(_, path) => path.freeVars
     case Tup(_, _) => Set.empty
+    case Field(_, _) => Set.empty
 
   lazy val freeVarsLLIR: Set[Local] = this match
     case Lit(_) => Set.empty
     case Cls(_, path) => path.freeVarsLLIR
     case Tup(_, _) => Set.empty
+    case Field(_, _) => Set.empty
 
 sealed trait TrivialResult extends Result
 

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

@@ -202,6 +202,7 @@ class BlockTransformer(subst: SymbolSubst):
       val path2 = applyPath(path)
       if (cls2 is cls) && (path2 is path) then cse else Case.Cls(cls2, path2)
     case Case.Tup(len, inf) => cse
+    case Case.Field(name, safe) => cse
 
   def applyHandler(hdr: Handler): Handler =
     val sym2 = hdr.sym.subst

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

@@ -490,6 +490,17 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                       (cse, Assign(arg, Select(sr, param.id/*FIXME incorrect Ident?*/)(S(param)), blk))
                   mkMatch(mkArgs(clsParams.iterator.zip(args).collect { case (s1, S(s2)) => (s1, s2) }.toList))
               case Pattern.Tuple(len, inf) => mkMatch(Case.Tup(len, inf) -> go(tail, topLevel = false))
+              case Pattern.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(go(tail, 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) =>
           if k.isInstanceOf[TailOp] && isIf then term_nonTail(els)(k)
           else

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

@@ -375,6 +375,10 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
           case Elaborator.ctx.builtins.Int => doc"globalThis.Number.isInteger($sd)"
           case _ => doc"$sd instanceof ${result(pth)}"
         case Case.Tup(len, inf) => doc"globalThis.Array.isArray($sd) && $sd.length ${if inf then ">=" else "==="} ${len}"
+        case Case.Field(n, safe = false) =>
+          doc"""typeof $sd === "object" && $sd !== null && "${n.name}" in $sd"""
+        case Case.Field(n, safe = true) =>
+          doc""""${n.name}" in $sd"""
       val h = doc" # if (${ cond(hd._1) }) ${ braced(returningTerm(hd._2, endSemi = false)) }"
       val t = tl.foldLeft(h)((acc, arm) =>
         acc :: doc" else if (${ cond(arm._1) }) ${ braced(returningTerm(arm._2, endSemi = false)) }")

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

@@ -26,11 +26,8 @@ enum Pattern extends AutoLocated:
   case Record(entries: List[(Ident -> BlockLocalSymbol)])
 
   def subTerms: Ls[Term] = this match
-    case Lit(_) => Nil
     case ClassLike(_, t, _, _) => t :: Nil
-    case Synonym(_, _) => Nil
-    case Tuple(_, _) => Nil
-    case Record(_) => Nil
+    case _: (Lit | Synonym | Tuple | Record) => Nil 
 
   def children: Ls[Located] = this match
     case Lit(literal) => literal :: Nil

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

@@ -7,7 +7,7 @@ import mlscript.utils.*, shorthands.*
 import Message.MessageContext
 import utils.TraceLogger
 import syntax.Literal
-import Keyword.{as, and, `do`, `else`, is, let, `then`}
+import Keyword.{as, and, `do`, `else`, is, let, `then`, where}
 import collection.mutable.{HashMap, SortedSet}
 import Elaborator.{ctx, Ctxl}
 import scala.annotation.targetName
@@ -21,6 +21,7 @@ object Desugarer:
 
   class ScrutineeData:
     val classes: HashMap[ClassSymbol, List[BlockLocalSymbol]] = HashMap.empty
+    val fields: HashMap[Ident, BlockLocalSymbol] = HashMap.empty
     val tupleLead: HashMap[Int, BlockLocalSymbol] = HashMap.empty
     val tupleLast: HashMap[Int, BlockLocalSymbol] = HashMap.empty
 end Desugarer
@@ -89,18 +90,13 @@ class Desugarer(val elaborator: Elaborator)
     def ++(fallback: Split): Split =
       if fallback == Split.End then
         split
-      else if split.isFull then
-        raise:
-          ErrorReport:
-            msg"The following branches are unreachable." -> fallback.toLoc ::
-            msg"Because the previous split is full." -> split.toLoc :: Nil
-        split
       else (split match
         case Split.Cons(head, tail) => Split.Cons(head, tail ++ fallback)
         case Split.Let(name, term, tail) => Split.Let(name, term, tail ++ fallback)
-        case Split.Else(_) /* impossible */ | Split.End => fallback)
+        case Split.Else(_) | Split.End => fallback)
 
   private val subScrutineeMap = HashMap.empty[BlockLocalSymbol, ScrutineeData]
+  private val fieldScrutineeMap = HashMap.empty[BlockLocalSymbol, ScrutineeData]
 
   extension (symbol: BlockLocalSymbol)
     def getSubScrutinees(cls: ClassSymbol): List[BlockLocalSymbol] =
@@ -113,6 +109,11 @@ class Desugarer(val elaborator: Elaborator)
     def getTupleLastSubScrutinee(index: Int): BlockLocalSymbol =
       val data = subScrutineeMap.getOrElseUpdate(symbol, new ScrutineeData)
       data.tupleLast.getOrElseUpdate(index, TempSymbol(N, s"last$index"))
+    def getFieldScrutinee(fieldName: Ident): BlockLocalSymbol =
+      subScrutineeMap
+        .getOrElseUpdate(symbol, new ScrutineeData)
+        .fields
+        .getOrElseUpdate(fieldName, TempSymbol(N, s"field${fieldName.name}"))
 
 
   def default: Split => Sequel = split => _ => split
@@ -459,9 +460,7 @@ class Desugarer(val elaborator: Elaborator)
         if pat.patternParams.size > 0 then
           error(
             msg"Pattern `${pat.nme}` expects ${"pattern argument".pluralize(pat.patternParams.size, true)}" ->
-              pat.patternParams.foldLeft[Opt[Loc]](N):
-              case (N, param) => param.sym.toLoc
-              case (S(loc), param) => S(loc ++ param.sym.toLoc),
+              Loc(pat.patternParams.iterator.map(_.sym)),
             msg"But no arguments were given" -> ctor.toLoc)
           fallback
         else
@@ -508,12 +507,8 @@ class Desugarer(val elaborator: Elaborator)
         if pat.patternParams.size != patArgs.size then
           error(
             msg"Pattern `${pat.nme}` expects ${"pattern argument".pluralize(pat.patternParams.size, true)}" ->
-              pat.patternParams.foldLeft[Opt[Loc]](N):
-              case (N, param) => param.sym.toLoc
-              case (S(loc), param) => S(loc ++ param.sym.toLoc),
-            msg"But ${"pattern argument".pluralize(patArgs.size, true)} were given" -> args.foldLeft[Opt[Loc]](N):
-              case (N, arg) => arg.toLoc
-              case (S(loc), arg) => S(loc ++ arg.toLoc))
+              Loc(pat.patternParams.iterator.map(_.sym)),
+            msg"But ${"pattern argument".pluralize(patArgs.size, true)} were given" -> Loc(args))
           fallback
         else
           Branch(ref, Pattern.Synonym(pat, patArgs.zip(args)), sequel(ctx)) ~: fallback
@@ -589,6 +584,12 @@ class Desugarer(val elaborator: Elaborator)
         Branch(ref, Pattern.Lit(IntLit(-value)), sequel(ctx)) ~: fallback
       case App(Ident("-"), Tup(DecLit(value) :: Nil)) => fallback => ctx =>
         Branch(ref, Pattern.Lit(DecLit(-value)), sequel(ctx)) ~: fallback
+      case App(Ident("&"), Tree.Tup(lhs :: rhs :: Nil)) => fallback => ctx =>
+        val newSequel = expandMatch(scrutSymbol, rhs, sequel)(fallback)
+        expandMatch(scrutSymbol, lhs, newSequel)(fallback)(ctx)
+      case App(Ident("|"), Tree.Tup(lhs :: rhs :: Nil)) => fallback => ctx =>
+        val newFallback = expandMatch(scrutSymbol, rhs, sequel)(fallback)(ctx)
+        expandMatch(scrutSymbol, lhs, sequel)(newFallback)(ctx)
       // A single constructor pattern.
       case Annotated(Ident("compile"), app @ App(ctor: Ctor, Tup(args))) =>
         dealWithAppCtorCase(app, ctor, args, true)
@@ -607,18 +608,50 @@ class Desugarer(val elaborator: Elaborator)
       case pattern and consequent => fallback => ctx =>
         val innerSplit = termSplit(consequent, identity)(Split.End)
         expandMatch(scrutSymbol, pattern, innerSplit)(fallback)(ctx)
+      case pattern where condition => fallback => ctx =>
+        val sym = TempSymbol(N, "conditionTemp")
+        val newSequel = expandMatch(sym, Tree.BoolLit(true), sequel)(fallback)
+        val newNewSequel = (ctx: Ctx) => Split.Let(sym, term(condition)(using ctx), newSequel(ctx))
+        expandMatch(scrutSymbol, pattern, newNewSequel)(fallback)(ctx)
       case Jux(Ident(".."), Ident(_)) => fallback => _ =>
         raise(ErrorReport(msg"Illegal rest pattern." -> pattern.toLoc :: Nil))
         fallback
-      case InfixApp(id: Ident, Keyword.`:`, pat) => fallback => ctx =>
-        val sym = VarSymbol(id)
-        val ctx2 = ctx
-          // + (id.name -> sym) // * This binds the field's name in the context; probably surprising
-        Split.Let(sym, ref.sel(id, N),
-          expandMatch(sym, pat, sequel)(fallback)(ctx2))
+      case InfixApp(fieldName: Ident, Keyword.`:`, pat) => fallback => ctx =>
+        val symbol = scrutSymbol.getFieldScrutinee(fieldName)
+        Branch(
+          ref,
+          Pattern.Record((fieldName, symbol) :: Nil),
+          subMatches((R(symbol), pat) :: Nil, sequel)(Split.End)(ctx)
+        ) ~: fallback
+      case Pun(false, fieldName) => fallback => ctx =>
+        val symbol = scrutSymbol.getFieldScrutinee(fieldName)
+        Branch(
+          ref,
+          Pattern.Record((fieldName, symbol) :: Nil),
+          subMatches((R(symbol), fieldName) :: Nil, sequel)(Split.End)(ctx)
+        ) ~: fallback
       case Block(st :: Nil) => fallback => ctx =>
         expandMatch(scrutSymbol, st, sequel)(fallback)(ctx)
-      // case Block(sts) => fallback => ctx => // TODO
+      case Block(sts) => fallback => ctx => // we assume this is a record
+        sts.foldRight[Option[List[(Tree.Ident, BlockLocalSymbol, Tree)]]](S(Nil)){
+          // this collects the record parts, or fails if some statement does not correspond
+          // to a record field
+          case (_, N) => N // we only need to fail once to return N
+          case (p, S(tl)) => p match
+            case InfixApp(fieldName: Ident, Keyword.`:`, pat) =>
+              S((fieldName, scrutSymbol.getFieldScrutinee(fieldName), pat) :: tl)
+            case Pun(false, fieldName) =>
+              S((fieldName, scrutSymbol.getFieldScrutinee(fieldName), fieldName) :: tl)
+            case p =>
+              raise(ErrorReport(msg"invalid record field pattern" -> p.toLoc :: Nil))
+              None
+        }.fold(fallback)(recordContent =>
+          Branch(
+            ref,
+            Pattern.Record(recordContent.map((fieldName, symbol, _) => (fieldName, symbol))),
+            subMatches(recordContent.map((_, symbol, pat) => (R(symbol), pat)), sequel)(Split.End)(ctx)
+          ) ~: fallback
+        )
       case Bra(BracketKind.Curly | BracketKind.Round, inner) => fallback => ctx =>
         expandMatch(scrutSymbol, inner, sequel)(fallback)(ctx)
       case pattern => fallback => _ =>

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

@@ -13,6 +13,12 @@ object HelperExtractors:
       case App(Ident("|"), Tup(lhs :: rhs :: Nil)) => S(lhs, rhs)
       case _ => N
 
+  /** A helper extractor for matching the tree of `x a y`.*/
+  object and:
+    infix def unapply(tree: App): Opt[(Tree, Tree)] = tree match
+      case App(Ident("&"), Tup(lhs :: rhs :: Nil)) => S(lhs, rhs)
+      case _ => N
+
   /** A helper extractor for matching the tree of `x ..= y` and `x ..< y`.
    *  The Boolean value indicates whether the range is inclusive.
    */

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

@@ -6,6 +6,7 @@ import mlscript.utils.*, shorthands.*
 import syntax.{Literal, Tree}, utils.TraceLogger
 import Message.MessageContext
 import Elaborator.Ctx
+import hkmc2.semantics.ClassDef.Parameterized
 
 class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
   import Normalization.*, Mode.*
@@ -47,7 +48,14 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
       case (c1: Pattern.ClassLike, c2: Pattern.ClassLike) => c1.sym === c2.sym
       case (Pattern.Lit(l1), Pattern.Lit(l2)) => l1 === l2
       case (Pattern.Tuple(n1, b1), Pattern.Tuple(n2, b2)) => n1 === n2 && b1 === b2
-      case (_, _) => false
+      case (Pattern.Record(ls1), Pattern.Record(ls2)) =>
+        ls1.lazyZip(ls2).forall:
+          case ((fieldName1, p1), (fieldName2, p2)) =>
+            fieldName1 === fieldName2 && p1 === p2
+      case (Pattern.Synonym(sym1, args1), Pattern.Synonym(sym2, args2)) =>
+        args1 === args2 && sym1.params === sym2.params && sym1.body === sym2.body
+      case (_: Pattern.ClassLike, _) | (_: Pattern.Lit, _) |
+        (_: Pattern.Tuple, _) | (_: Pattern.Synonym, _) | (_: Pattern.Record, _) => false
     /** Checks if `lhs` can be subsumed under `rhs`. */
     def <:<(rhs: Pattern): Bool = compareCasePattern(lhs, rhs)
     /**
@@ -68,6 +76,23 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
       case lhs: Pattern.ClassLike => lhs.refined = true
       case _ => ()
 
+  extension (lhs: Pattern.Record)
+    /** reduces the record pattern `lhs` assuming we have matched `rhs`.
+      * It removes field matches that may now be unnecessary
+      */
+    infix def assuming(rhs: Pattern): Pattern.Record = rhs match
+      case Pattern.Record(rhsEntries) =>
+        val filteredEntries = lhs.entries.filter:
+          (fieldName1, _) => rhsEntries.forall { (fieldName2, _) => !(fieldName1 === fieldName2)}
+        Pattern.Record(filteredEntries)
+      case Pattern.ClassLike(sym = cls : ClassSymbol) => cls.defn match
+        case S(ClassDef.Parameterized(params = paramList)) =>
+          val filteredEntries = lhs.entries.filter:
+            (fieldName1, _) => paramList.params.forall { (param:Param) => !(fieldName1 === param.sym.id)}
+          Pattern.Record(filteredEntries)
+        case S(_) | N => lhs
+      case _ => lhs
+
   inline def apply(split: Split): Split = normalize(split)(using VarSet())
 
   /**
@@ -82,7 +107,7 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
   ):
     def rec(split: Split)(using vs: VarSet): Split = split match
       case Split.Cons(Branch(scrutinee, pattern, consequent), alternative) => pattern match
-        case pattern: (Pattern.Lit | Pattern.ClassLike | Pattern.Tuple) =>
+        case pattern: (Pattern.Lit | Pattern.ClassLike | Pattern.Tuple | Pattern.Record) =>
           log(s"MATCH: ${scrutinee.showDbg} is ${pattern.showDbg}")
           val whenTrue = normalize(specialize(consequent ++ alternative, +, scrutinee, pattern))
           val whenFalse = rec(specialize(alternative, -, scrutinee, pattern).clearFallback)
@@ -154,8 +179,9 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
 
   /**
     * Specialize `split` with the assumption that `scrutinee` matches `pattern`.
-    * If `matchOrNot` is `true`, the function _keeps_ branches that agree on
-    * `scrutinee` matches `pattern`. Otherwise, the function _removes_ branches
+    * If `mode` is `+`, the function _keeps_ branches that agree on
+    * `scrutinee` matching `pattern` and simplifies the record patterns it sees if the fields were already matched.
+    * Otherwise (if `mode` is `-`), the function _removes_ branches
     * that agree on `scrutinee` matches `pattern`.
     */
   private def specialize(
@@ -188,23 +214,35 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
             else if split.isFallback then
               log(s"Case 1.1.3: $pattern is unrelated with $thatPattern")
               rec(tail)
-            else if pattern <:< thatPattern then
-              // TODO: the warning will be useful when we have inheritance information
-              // raiseDesugaringWarning(
-              //   msg"the pattern always matches" -> thatPattern.toLoc,
-              //   msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
-              //   msg"which is a subtype of ${thatPattern.toString}" -> (pattern match {
-              //     case Pattern.Class(cls, _, _) => cls.toLoc
-              //     case _ => thatPattern.toLoc
-              //   }))
-              rec(continuation) ++ rec(tail)
-            else
-              // TODO: the warning will be useful when we have inheritance information
-              // raiseDesugaringWarning(
-              //   msg"possibly conflicting patterns for this scrutinee" -> scrutinee.toLoc,
-              //   msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
-              //   msg"which is unrelated with ${thatPattern.toString}" -> thatPattern.toLoc)
-              rec(tail)
+            else thatPattern match
+            case thatPattern :Pattern.Record =>
+              log(s"Case 1.1.4: $thatPattern is a record")
+              // we can use information if pattern is itself a record, or if it is a constructor with arguments
+              val simplifiedRecord = thatPattern assuming pattern
+              if simplifiedRecord.entries.isEmpty then
+                tail
+              else
+                Split.Cons(Branch(thatScrutinee, simplifiedRecord, continuation), tail)
+            case _ =>
+              if pattern <:< thatPattern then
+                // TODO: the warning will be useful when we have inheritance information
+                // raiseDesugaringWarning(
+                //   msg"the pattern always matches" -> thatPattern.toLoc,
+                //   msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
+                //   msg"which is a subtype of ${thatPattern.toString}" -> (pattern match {
+                //     case Pattern.Class(cls, _, _) => cls.toLoc
+                //     case _ => thatPattern.toLoc
+                //   }))
+                log(s"case 1.1.5: $pattern <:< $thatPattern")
+                split
+              else
+                // TODO: the warning will be useful when we have inheritance information
+                // raiseDesugaringWarning(
+                //   msg"possibly conflicting patterns for this scrutinee" -> scrutinee.toLoc,
+                //   msg"the scrutinee was matched against ${pattern.toString}" -> pattern.toLoc,
+                //   msg"which is unrelated with ${thatPattern.toString}" -> thatPattern.toLoc)
+                log(s"Case 1.1._ else : ${tail}")
+                rec(tail)
           case - =>
             log(s"Case 1.2: $scrutinee === $thatScrutinee")
             thatPattern reportInconsistentRefinedWith pattern
@@ -249,7 +287,17 @@ object Normalization:
     case (Lit(Tree.StrLit(_)), ClassLike(blt.`Str`, _, _, _)) => true
     case (Lit(Tree.DecLit(_)), ClassLike(blt.`Num`, _, _, _)) => true
     case (Lit(Tree.BoolLit(_)), ClassLike(blt.`Bool`, _, _, _)) => true
-    case (_, _) => false
+    case (_: Synonym, _: Synonym) => lhs =:= rhs
+    case (Record(entries1), Record(entries2)) =>
+      entries1.forall { (fieldName1, _) => entries2.exists { (fieldName2, _) => fieldName1 === fieldName2 } }
+    case (Record(entries), ClassLike(sym = cs: ClassSymbol)) =>
+      val clsParams = cs.defn match
+        case S(Parameterized(params = paramList)) => paramList.params
+        case (S(_) | N) => Nil
+      entries.forall { (fieldName, _) => clsParams.exists {
+        case Param(flags = FldFlags(value = value), sym = sym) => value && fieldName === sym.id
+      }}
+    case (_: (ClassLike | Tuple | Lit | Record | Synonym), _)  => false
 
   final case class VarSet(declared: Set[BlockLocalSymbol]):
     def +(nme: BlockLocalSymbol): VarSet = copy(declared + nme)