Preliminary implementation of refining patterns (hkust-taco#262)

Author: chengluyu

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

@@ -209,7 +209,7 @@ class JSBuilder(using Elaborator.State, Elaborator.Ctx) extends CodeBuilder:
               val clsTmp = summon[Scope].allocateName(new semantics.TempSymbol(N, sym.nme+"$"+"class"))
               clsDefn.owner match
               case S(owner) =>
-                assert(clsDefn.paramsOpt.isEmpty)
+                assert((clsDefn.kind is syntax.Pat) || clsDefn.paramsOpt.isEmpty)
                 // doc"${mkThis(owner)}.${sym.nme} = new ${clsJS}"
                 doc"const $clsTmp = ${clsJS}; # ${mkThis(owner)}.${sym.nme} = new ${clsTmp
                   }; # ${mkThis(owner)}.${sym.nme}.class = $clsTmp;"
@@ -250,7 +250,6 @@ class JSBuilder(using Elaborator.State, Elaborator.Ctx) extends CodeBuilder:
     case Match(scrut, hd :: tl, els, rest) =>
       val sd = result(scrut)
       def cond(cse: Case) = cse match
-        case Case.Lit(syntax.Tree.BoolLit(true)) => sd
         case Case.Lit(lit) => doc"$sd === ${lit.idStr}"
         case Case.Cls(cls, pth) => cls match
           // case _: semantics.ModuleSymbol => doc"=== ${result(pth)}"

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

@@ -162,6 +162,14 @@ extends Importer:
         N
     case _ => N
 
+  /** To perform a reverse lookup for a term that references a symbol in the current context. */
+  def reference(target: ClassSymbol | ModuleSymbol): Ctxl[Opt[Term]] =
+    def go(ctx: Ctx): Opt[Term] =
+      ctx.env.values.collectFirst:
+        case elem if elem.symbol.flatMap(_.asClsLike).contains(target) => elem.ref(target.id)
+      .orElse(ctx.parent.flatMap(go))
+    go(ctx).map(Term.SynthSel(_, Ident("class"))(S(target)))
+  
   def cls(tree: Tree, inAppPrefix: Bool): Ctxl[Term] = trace[Term](s"Elab class ${tree.showDbg}", r => s"~> $r"):
     val trm = term(tree, inAppPrefix)
     trm.symbol match
@@ -289,8 +297,12 @@ extends Importer:
     case InfixApp(lhs, Keyword.`:`, rhs) =>
       Term.Asc(term(lhs), term(rhs))
     case tree @ InfixApp(lhs, Keyword.`is` | Keyword.`and`, rhs) =>
-      val des = new Desugarer(this)(tree)
-      val nor = new ucs.Normalization(tl)(des)
+      val des = new ucs.Desugarer(this)(tree)
+      scoped("ucs:desugared"):
+        log(s"Desugared:\n${Split.display(des)}")
+      val nor = new ucs.Normalization(this)(des)
+      scoped("ucs:normalized"):
+        log(s"Normalized:\n${Split.display(nor)}")
       Term.IfLike(Keyword.`if`, des)(nor)
     case app @ PartialApp(lhs, args) =>
       var params: Ls[Param] = Nil
@@ -428,21 +440,21 @@ extends Importer:
       // case _ =>
       //   raise(ErrorReport(msg"Illegal new expression." -> tree.toLoc :: Nil))
     case tree @ Tree.IfLike(kw, _, split) =>
-      val desugared = new Desugarer(this)(tree)
+      val desugared = new ucs.Desugarer(this)(tree)
       scoped("ucs:desugared"):
         log(s"Desugared:\n${Split.display(desugared)}")
-      val normalized = new ucs.Normalization(tl)(desugared)
+      val normalized = new ucs.Normalization(this)(desugared)
       scoped("ucs:normalized"):
         log(s"Normalized:\n${Split.display(normalized)}")
       Term.IfLike(kw, desugared)(normalized)
     case Tree.Quoted(body) => Term.Quoted(term(body))
     case Tree.Unquoted(body) => Term.Unquoted(term(body))
     case tree @ Tree.Case(_, branches) =>
       val scrut = VarSymbol(Ident("caseScrut"))
-      val des = new Desugarer(this)(tree, scrut)
+      val des = new ucs.Desugarer(this)(tree, scrut)
       scoped("ucs:desugared"):
         log(s"Desugared:\n${Split.display(des)}")
-      val nor = new ucs.Normalization(tl)(des)
+      val nor = new ucs.Normalization(this)(des)
       scoped("ucs:normalized"):
         log(s"Normalized:\n${Split.display(nor)}")
       Term.Lam(PlainParamList(
@@ -851,9 +863,29 @@ extends Importer:
           val owner = ctx.outer
           newCtx.nest(S(patSym)).givenIn:
             assert(body.isEmpty)
+            td.extension match
+              case N => raise(ErrorReport(msg"Pattern definitions must have a body." -> td.toLoc :: Nil))
+              case S(tree) =>
+                val (patternParams, extractionParams) = ps match // Filter out pattern parameters.
+                  case S(ParamList(_, params, _)) => params.partition:
+                    case param @ Param(FldFlags(false, false, false, false, true), _, _) => true
+                    case param @ Param(FldFlags(_, _, _, _, false), _, _) => false
+                  case N => (Nil, Nil)
+                // TODO: Implement extraction parameters.
+                if extractionParams.nonEmpty then
+                  raise(ErrorReport(msg"Pattern extraction parameters are not yet supported." ->
+                    Loc(extractionParams.iterator.map(_.sym)) :: Nil))
+                log(s"pattern parameters: ${patternParams.mkString("{ ", ", ", " }")}")
+                patSym.patternParams = patternParams
+                val split = ucs.DeBrujinSplit.elaborate(patternParams, tree, this)
+                scoped("ucs:rp:elaborated"):
+                  log(s"elaborated ${patSym.nme}:\n${split.display}")
+                patSym.split = split
             log(s"pattern body is ${td.extension}")
             val translate = new ucs.Translator(this)
-            val bod = translate(ps.map(_.params).getOrElse(Nil), td.extension.getOrElse(die))
+            val bod = translate(patSym.patternParams,
+                                Nil, // ps.map(_.params).getOrElse(Nil), // TODO: remove pattern parameters
+                                td.extension.getOrElse(die))
             val pd = PatternDef(owner, patSym, tps, ps, ObjBody(Term.Blk(bod, Term.Lit(UnitLit(true)))), annotations)
             patSym.defn = S(pd)
             pd
@@ -924,6 +956,8 @@ extends Importer:
           raise(ErrorReport(msg"Module parameters must have concrete types." -> t.toLoc :: Nil))
         case _ => ()
       ps
+    case TypeDef(Pat, inner, N, N) =>
+      param(inner).map(_.mapSecond(p => p.copy(flags = p.flags.copy(pat = true))))
     case _ =>
       t.asParam.map: (isSpd, p, t) =>
         isSpd -> Param(FldFlags.empty, fieldOrVarSym(ParamBind, p), t.map(term(_)))

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

@@ -3,26 +3,30 @@ package semantics
 
 import mlscript.utils.*, shorthands.*
 import syntax.*, Tree.Ident
+import ucs.DeBrujinSplit
 
 /** Flat patterns for pattern matching */
 enum Pattern extends AutoLocated:
   case Lit(literal: Literal)
   case Var(sym: BlockLocalSymbol)
   case ClassLike(sym: ClassSymbol | ModuleSymbol, trm: Term, parameters: Opt[List[BlockLocalSymbol]], var refined: Bool)(val tree: Tree)
+  case Synonym(symbol: PatternSymbol, patternArguments: Ls[(split: DeBrujinSplit, tree: Tree)])
   case Tuple(size: Int, inf: Bool)
   case Record(entries: List[(Ident -> BlockLocalSymbol)])
 
   def subTerms: Ls[Term] = this match
     case Lit(_) => Nil
     case Var(_) => Nil
     case ClassLike(_, t, _, _) => t :: Nil
+    case Synonym(_, _) => Nil
     case Tuple(_, _) => Nil
     case Record(_) => Nil
 
   def children: Ls[Located] = this match
     case Lit(literal) => literal :: Nil
     case Var(nme) => Nil
     case ClassLike(_, t, parameters, _) => t :: parameters.toList.flatten
+    case Synonym(_, arguments) => arguments.map(_.tree)
     case Tuple(fields, _) => Nil
     case Record(entries) => entries.flatMap { case (nme, als) => nme :: als :: Nil }
 
@@ -31,9 +35,9 @@ enum Pattern extends AutoLocated:
     case Var(sym) => sym.nme
     case ClassLike(sym, t, ps, rfd) => (if rfd then "refined " else "") +
       sym.nme + ps.fold("")(_.mkString("(", ", ", ")"))
+    case Synonym(symbol, arguments) =>
+      symbol.nme + arguments.iterator.map(_.tree.showDbg).mkString("(", ", ", ")")
     case Tuple(size, inf) => "[]" + (if inf then ">=" else "=") + size
     case Record(Nil) => "{}"
     case Record(entries) =>
       entries.iterator.map(_.name + ": " + _).mkString("{ ", ", ", " }")
-      
-

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

@@ -61,6 +61,15 @@ enum Split extends AutoLocated with ProductWithTail:
   var isFallback: Bool = false
 end Split
 
+extension (split: Split)
+  def ~~:(fallback: Split): Split =
+    if fallback == Split.End || split.isFull then
+      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)
+
 object Split:
   def default(term: Term): Split = Split.Else(term)
 

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

@@ -177,15 +177,17 @@ type FieldSymbol = TermSymbol | MemberSymbol[?]
 sealed trait InnerSymbol extends Symbol
 
 class ClassSymbol(val tree: Tree.TypeDef, val id: Tree.Ident)(using State)
-    extends MemberSymbol[ClassDef] with CtorSymbol with InnerSymbol:
+    extends MemberSymbol[ClassDef] with CtorSymbol with InnerSymbol with NamedSymbol:
+  def name: Str = nme
   def nme = id.name
   def toLoc: Option[Loc] = id.toLoc // TODO track source tree of classe here
   override def toString: Str = s"class:$nme${State.dbgUid(uid)}"
   /** Compute the arity. */
   def arity: Int = tree.paramLists.headOption.fold(0)(_.fields.length)
 
 class ModuleSymbol(val tree: Tree.TypeDef, val id: Tree.Ident)(using State)
-    extends MemberSymbol[ModuleDef] with CtorSymbol with InnerSymbol:
+    extends MemberSymbol[ModuleDef] with CtorSymbol with InnerSymbol with NamedSymbol:
+  def name: Str = nme
   def nme = id.name
   def toLoc: Option[Loc] = id.toLoc // TODO track source tree of module here
   override def toString: Str = s"module:${id.name}${State.dbgUid(uid)}"
@@ -195,11 +197,20 @@ class TypeAliasSymbol(val id: Tree.Ident)(using State) extends MemberSymbol[Type
   def toLoc: Option[Loc] = id.toLoc // TODO track source tree of type alias here
   override def toString: Str = s"module:${id.name}${State.dbgUid(uid)}"
 
-class PatternSymbol(val id: Tree.Ident)(using State)
+class PatternSymbol(val id: Tree.Ident, val params: Opt[Tree.Tup], val body: Tree)(using State)
     extends MemberSymbol[PatternDef] with CtorSymbol with InnerSymbol:
   def nme = id.name
   def toLoc: Option[Loc] = id.toLoc // TODO track source tree of pattern here
   override def toString: Str = s"pattern:${id.name}"
+  /** The desugared nameless split. */
+  private var _split: Opt[ucs.DeBrujinSplit] = N
+  def split_=(split: ucs.DeBrujinSplit): Unit = _split = S(split)
+  def split: ucs.DeBrujinSplit = _split.getOrElse:
+    lastWords(s"found unelaborated pattern: $nme")
+  /** The list of pattern parameters, for example,
+    * `T` in `pattern Nullable(pattern T) = null | T`.
+    */
+  var patternParams: Ls[Param] = Nil
 
 class TopLevelSymbol(blockNme: Str)(using State)
     extends MemberSymbol[ModuleDef] with InnerSymbol:

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

@@ -342,18 +342,19 @@ case class TypeDef(
 
 
 // TODO Store optional source locations for the flags instead of booleans
-final case class FldFlags(mut: Bool, spec: Bool, genGetter: Bool, mod: Bool):
+final case class FldFlags(mut: Bool, spec: Bool, genGetter: Bool, mod: Bool, pat: Bool):
   def showDbg: Str = 
     val flags = Buffer.empty[String]
     if mut then flags += "mut"
     if spec then flags += "spec"
     if genGetter then flags += "gen"
     if mod then flags += "module"
+    if pat then flags += "pattern"
     flags.mkString(" ")
   override def toString: String = "‹" + showDbg + "›"
 
 object FldFlags:
-  val empty: FldFlags = FldFlags(false, false, false, false)
+  val empty: FldFlags = FldFlags(false, false, false, false, false)
   object benign:
     // * Some flags like `mut` and `module` are "benign" in the sense that they don't affect code-gen
     def unapply(flags: FldFlags): Bool =