The Ultimate Pattern Syntax (#316)

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

Author: 4 people

hkmc2/shared/src/main/scala/hkmc2/Message.scala

@@ -29,8 +29,9 @@ object Message:
   sealed abstract class Bit
   final case class Text(str: Str) extends Bit
   final case class Code(ty: TypeLike) extends Bit
-  implicit def fromType(ty: TypeLike): Message = Message(Code(ty)::Nil)
-  implicit def fromStr(str: Str): Message = Message(Text(str)::Nil)
+  implicit def fromType(ty: TypeLike): Message = Message(Code(ty) :: Nil)
+  implicit def fromStr(str: Str): Message = Message(Text(str) :: Nil)
+  implicit def fromInt(int: Int): Message = Message(Text(int.toString) :: Nil)
 
   implicit class MessageContext(private val ctx: StringContext):
     def msg(inserted: Message*): Message =

hkmc2/shared/src/main/scala/hkmc2/bbml/bbML.scala

@@ -9,7 +9,7 @@ import mlscript.utils.*, shorthands.*
 import utils.*
 
 import Message.MessageContext
-import semantics.*, semantics.Term.*
+import semantics.*, Term.*, ucs.FlatPattern
 import Elaborator.Ctx
 import syntax.*
 import Tree.*
@@ -258,7 +258,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       val res = freshVar(new TempSymbol(S(blk), "ctx"))(using ctx)
       constrain(bodyCtx, sk | res)
       (bodyTy, rhsCtx | res, rhsEff | bodyEff)
-    case Term.IfLike(Keyword.`if`, Split.Let(_, cond, Split.Cons(Branch(_, Pattern.Lit(BoolLit(true)), Split.Else(cons)), Split.Else(alts)))) =>
+    case Term.IfLike(Keyword.`if`, Split.Let(_, cond, Split.Cons(Branch(_, FlatPattern.Lit(BoolLit(true)), Split.Else(cons)), Split.Else(alts)))) =>
       val (condTy, condCtx, condEff) = typeCode(cond)
       val (consTy, consCtx, consEff) = typeCode(cons)
       val (altsTy, altsCtx, altsEff) = typeCode(alts)
@@ -295,7 +295,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
       val nestCtx1 = ctx.nest
       val nestCtx2 = ctx.nest
       val patTy = pattern match
-      case pat: Pattern.ClassLike =>
+      case pat: FlatPattern.ClassLike =>
         pat.constructor.symbol.flatMap(_.asCls) match
           case S(sym) =>
             val (clsTy, tv, emptyTy) = sym.defn.map(sym -> _) match
@@ -313,7 +313,7 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
           case N =>
             error(msg"Not a valid class: ${pat.constructor.describe}" -> pat.constructor.toLoc :: Nil)
             Bot
-      case Pattern.Lit(lit) => lit match
+      case FlatPattern.Lit(lit) => lit match
         case _: Tree.BoolLit => BbCtx.boolTy
         case _: Tree.IntLit => BbCtx.intTy
         case _: Tree.DecLit => BbCtx.numTy

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

@@ -10,7 +10,7 @@ import utils.*
 
 import hkmc2.Message.MessageContext
 
-import semantics.*
+import semantics.*, ucs.FlatPattern
 import hkmc2.{semantics => sem}
 import semantics.{Term => st}
 import semantics.Term.{Throw => _, *}
@@ -184,7 +184,9 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         blockImpl(stats, res)(k)
       case cls: ClassLikeDef =>
         reportAnnotations(cls, cls.extraAnnotations)
-        val (mtds, publicFlds, privateFlds, ctor) = gatherMembers(cls.body)
+        val (mtds, publicFlds, privateFlds, ctor) = cls match
+          case pd: PatternDef => compilePatternMethods(pd)
+          case _ => gatherMembers(cls.body)
         cls.ext match
         case N =>
           Define(ClsLikeDefn(cls.owner, cls.sym, cls.bsym, cls.kind, cls.paramsOpt, cls.auxParams, N,
@@ -341,7 +343,9 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         case _: sem.BuiltinSymbol => true
         case sym: sem.BlockMemberSymbol =>
           sym.trmImplTree.fold(sym.clsTree.isDefined)(_.k is syntax.Fun)
-        case _ => false
+        // Do not perform safety check on `MatchResult` and `MatchFailure`.
+        case sym => (sym is State.matchResultClsSymbol) ||
+          (sym is State.matchFailureClsSymbol)
       def conclude(fr: Path) =
         arg match
         case Tup(fs) =>
@@ -506,8 +510,8 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                 End()
               )
             pat match
-              case Pattern.Lit(lit) => mkMatch(Case.Lit(lit) -> go(tail, topLevel = false))
-              case Pattern.ClassLike(ctor, argsOpt, _mode, _refined) =>
+              case FlatPattern.Lit(lit) => mkMatch(Case.Lit(lit) -> go(tail, 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 =
                   val args = argsOpt.map(_.map(_.scrutinee)).getOrElse(Nil)
@@ -537,8 +541,8 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                     // 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 Pattern.Tuple(len, inf) => mkMatch(Case.Tup(len, inf) -> go(tail, topLevel = false))
-              case Pattern.Record(entries) =>
+              case FlatPattern.Tuple(len, inf) => mkMatch(Case.Tup(len, inf) -> go(tail, 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))),
@@ -565,7 +569,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
       val normalized = tl.scoped("ucs:normalize"):
         normalize(iftrm.desugared)
       tl.scoped("ucs:normalized"):
-        tl.log(s"Normalized:\n${Split.display(normalized)}")
+        tl.log(s"Normalized:\n${normalized.prettyPrint}")
 
       if k.isInstanceOf[TailOp] && isIf then go(normalized, topLevel = true)
       else
@@ -683,8 +687,8 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
   def setupSymbol(symbol: Local)(k: Result => Block)(using Subst): Block =
     k(Instantiate(mut = false, Value.Ref(State.termSymbol).selSN("Symbol"), Value.Lit(Tree.StrLit(symbol.nme)) :: Nil))
 
-  def quotePattern(p: Pattern)(k: Result => Block)(using Subst): Block = p match
-    case Pattern.Lit(lit) => setupTerm("LitPattern", Value.Lit(lit) :: Nil)(k)
+  def quotePattern(p: FlatPattern)(k: Result => Block)(using Subst): Block = p match
+    case FlatPattern.Lit(lit) => setupTerm("LitPattern", Value.Lit(lit) :: Nil)(k)
     case _ => // TODO
       fail:
         ErrorReport(
@@ -819,6 +823,21 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
           case t => t
     (mtds, publicFlds, privateFlds, ctor)
 
+  /** Compile the pattern definition into `unapply` and `unapplyStringPrefix`
+   *  methods using the `NaiveCompiler`, which transliterate the pattern into
+   *  UCS splits that backtrack without any optimizations. */
+  def compilePatternMethods(defn: PatternDef)(using Subst):
+      // The return type is intended to be consistent with `gatherMembers`
+      (Ls[FunDefn], Ls[BlockMemberSymbol -> TermSymbol], Ls[TermSymbol], Block) =
+    val compiler = new ups.NaiveCompiler
+    val methods = compiler.compilePattern(defn)
+    val mtds = methods
+      .flatMap: td =>
+        td.body.map: bod =>
+          val (paramLists, bodyBlock) = setupFunctionDef(td.params, bod, S(td.sym.nme))
+          FunDefn(td.owner, td.sym, paramLists, bodyBlock)
+    (mtds, Nil, Nil, End())
+  
   def args(elems: Ls[Elem])(k: Ls[Arg] => Block)(using Subst): Block =
     val as = elems.map:
       case sem.Fld(sem.FldFlags.benign(), value, N) => R(N -> value)

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

@@ -169,6 +169,8 @@ class JSBuilder(using TL, State, Ctx) extends CodeBuilder:
         then doc"$runtimeVar.Tuple.lazyConcat(${es.map(argument).mkDocument(doc", ")})"
         else doc"[ #{  # ${es.map(argument).mkDocument(doc", # ")} #}  # ]"
       if mut then inner else s"$freeze(${inner})"
+    case Value.Rcd(mut, Nil) =>
+      if mut then "{}" else s"$freeze({})"
     case Value.Rcd(mut, flds) =>
       val inner = doc"{ #  #{ ${
           flds.map:

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

@@ -13,7 +13,7 @@ trait BlockImpl(using Elaborator.State):
   val desugStmts =
     def desug(stmts: Ls[Tree]): Ls[Tree] =
       stmts match
-      case PossiblyAnnotated(anns, syntax.Desugared(td: TypeDef)) :: stmts =>
+      case syntax.Desugared(PossiblyAnnotated(anns, td: TypeDef)) :: stmts =>
         val ctors = td.withPart.toList.flatMap:
           case Block(sts) => sts.flatMap:
             case Constructor(Block(ctors)) => ctors