Term.Resolved

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

@@ -479,8 +479,8 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         case sym: sem.BlockMemberSymbol =>
           sym.trmImplTree.fold(sym.clsTree.isDefined)(_.k is syntax.Fun)
         case sym: sem.TermSymbol => sym.k is syntax.Fun
-        // Do not perform safety check on `MatchResult` and `MatchFailure`.
-        case sym => (sym is State.matchResultClsSymbol) ||
+        // Do not perform safety check on `MatchSuccess` and `MatchFailure`.
+        case sym => (sym is State.matchSuccessClsSymbol) ||
           (sym is State.matchFailureClsSymbol)
       def conclude(fr: Path) = lowerCall(fr, isMlsFun, arg, t.toLoc)(k)
 

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

@@ -247,8 +247,8 @@ object Elaborator:
     val nonLocalRet =
       val id = new Ident("ret")
       BlockMemberSymbol(id.name, Nil, true)
-    val (matchResultClsSymbol, matchResultTrmSymbol) =
-      val id = new Ident("MatchResult")
+    val (matchSuccessClsSymbol, matchSuccessTrmSymbol) =
+      val id = new Ident("MatchSuccess")
       val td = TypeDef(syntax.Cls, App(id, Tup(Ident("output") :: Ident("bindings") :: Nil)), N)
       val cs = ClassSymbol(td, id)
       val ts = TermSymbol(syntax.Fun, N, id)

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

@@ -297,16 +297,10 @@ class Resolver(tl: TraceLogger)
         def simpleSplit(s: SimpleSplit): Unit = s match
           case SimpleSplit.Cons(head: SimpleSplit.Head.Match, tail) =>
             traverse(head.scrutinee, expect = NonModule(N))
-            head.pattern match
-              case FlatPattern.ClassLike(constructor = t) =>
-                head.pattern.subTerms.foreach:
-                  case `t` => traverse(t, expect = PatternConstructor(N))
-                  case other => traverse(other, expect = NonModule(N))
-              case _ =>
-                head.pattern.subTerms.foreach(traverse(_, expect = NonModule(N)))
-            split(head.continuation)
-            split(tail)
-          case Split.Let(sym, term, tail) =>
+            traversePattern(head.pattern)
+            simpleSplit(head.consequent)
+            simpleSplit(tail)
+          case SimpleSplit.Cons(SimpleSplit.Head.Let(sym, term), tail) =>
             traverse(term, expect = NonModule(N))
             simpleSplit(tail)
           case SimpleSplit.Else(default) =>
@@ -419,35 +413,6 @@ class Resolver(tl: TraceLogger)
 
       traverseBlock(cld.body.blk)(using withCtxParams)
 
-    def traversePattern(p: Pattern): Unit = p match
-      case _: (Pattern.Wildcard | Pattern.Literal | Pattern.Range) => ()
-      case Pattern.Constructor(target, patternArguments, arguments) =>
-        traverse(target, expect = PatternConstructor(N))
-        patternArguments.foreach(traversePattern(_))
-        arguments.foreach(_.foreach(traversePattern(_)))
-      case Pattern.Composition(_, left, right) =>
-        traversePattern(left)
-        traversePattern(right)
-      case Pattern.Negation(pattern) =>
-        traversePattern(pattern)
-      case Pattern.Concatenation(left, right) =>
-        traversePattern(left)
-        traversePattern(right)
-      case Pattern.Tuple(leading, spread, trailing) =>
-        leading.foreach(traversePattern(_))
-        spread.foreach(traversePattern(_))
-        trailing.foreach(traversePattern(_))
-      case Pattern.Record(fields) =>
-        fields.map((id, p) => traversePattern(p))
-      case Pattern.Chain(first, second) =>
-        traversePattern(first)
-        traversePattern(second)
-      case Pattern.Alias(pattern, _) =>
-        traversePattern(pattern)
-      case Pattern.Transform(pattern, transform) =>
-        traversePattern(pattern)
-        traverse(transform, expect = NonModule(N))
-
     defn match
 
     // Case: instance definition. Add the instance to the context.
@@ -487,6 +452,41 @@ class Resolver(tl: TraceLogger)
       t.subTerms.foreach(traverse(_, expect = NonModule(N)))
       ictx
 
+  def traversePattern(p: Pattern)(using ICtx): Unit = p match
+    case _: (Pattern.Wildcard | Pattern.Literal | Pattern.Range) => ()
+    case Pattern.Constructor(target, patternArguments) =>
+      traverse(target, expect = PatternConstructor(N))
+      patternArguments.foreach(_.foreach(traversePattern(_)))
+    case Pattern.Composition(_, left, right) =>
+      traversePattern(left)
+      traversePattern(right)
+    case Pattern.Negation(pattern) =>
+      traversePattern(pattern)
+    case Pattern.Concatenation(left, right) =>
+      traversePattern(left)
+      traversePattern(right)
+    case Pattern.Tuple(leading, spread) =>
+      leading.foreach(traversePattern(_))
+      spread.foreach: (_, spd, trailing) =>
+        traversePattern(spd)
+        trailing.foreach(traversePattern(_))
+    case Pattern.Record(fields) =>
+      fields.map((id, p) => traversePattern(p))
+    case Pattern.Chain(first, second) =>
+      traversePattern(first)
+      traversePattern(second)
+    case Pattern.Alias(pattern, _) =>
+      traversePattern(pattern)
+    case Pattern.Transform(pattern, _, transform) =>
+      traversePattern(pattern)
+      traverse(transform, expect = NonModule(N))
+    case Pattern.Annotated(pattern, annotations) =>
+      traversePattern(pattern)
+      annotations.map(_.toOption).flatten.foreach(traverse(_, expect = NonModule(N)))
+    case Pattern.Guarded(pattern, guard) =>
+      traversePattern(pattern)
+      traverse(guard, expect = NonModule(N))
+
   /**
     * Resolve a resolvable term. This involves:
     * 1. Resolving the sub-terms of the term. Because resolving a term

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

@@ -105,83 +105,11 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
     normalizeImpl(split)
 
   def normalizeImpl(split: Split)(using vs: VarSet): Split = split match
-    case Split.Cons(Branch(scrutinee, pattern, consequent), alternative) => pattern match
-      case pattern: (FlatPattern.Lit | FlatPattern.Tuple | FlatPattern.Record) =>
-        log(s"MATCH: ${scrutinee.showDbg} is ${pattern.showDbg}")
-        // TODO(ucs): deduplicate [1]
-        val whenTrue = aliasOutputSymbols(scrutinee, pattern.output,
-          normalize(specialize(consequent ++ alternative, +, scrutinee, pattern)))
-        val whenFalse = normalizeImpl(specialize(alternative, -, scrutinee, pattern).clearFallback)
-        Branch(scrutinee, pattern, whenTrue) ~: whenFalse
-      case pattern @ FlatPattern.ClassLike(ctor, argsOpt, mode, _) =>
-        log(s"MATCH: ${scrutinee.showDbg} is ${pattern.showDbg}")
-        // Make sure that the pattern has correct arity and fields are accessible.
-        ctor.symbol.map(_.asClsLike) match
-          case N => // The constructor is not resolved. The error should have been reported.
-            normalizeImpl(alternative)
-          case S(N) =>
-            // The constructor is not a class-like symbol. But it might be a
-            // `VarSymbol` referencing to a pattern parameter.
-            ctor.symbol match
-              case S(symbol: VarSymbol) => symbol.decl match
-                case S(param @ Param(flags = FldFlags(pat = true))) =>
-                  if argsOpt.fold(false)(_.nonEmpty) then
-                    error(msg"Pattern parameters cannot be applied." -> ctor.toLoc)
-                  mode match
-                    case MatchMode.Default =>
-                      normalizeExtractorPatternParameter(scrutinee, ctor, pattern.output, consequent, alternative)
-                    case sp: MatchMode.StringPrefix =>
-                      log(s"symbol name is ${symbol.nme}")
-                      normalizeStringPrefixPattern(scrutinee, ctor, N, sp, pattern.output, consequent, alternative)
-                    case MatchMode.Annotated(annotation) =>
-                      error(msg"Annotated pattern parameters are not supported here." -> annotation.toLoc)
-                      normalizeImpl(alternative)
-                case S(_) | N =>
-                  error(msg"Cannot use this ${ctor.describe} as a pattern" -> ctor.toLoc)
-                  normalizeImpl(alternative)
-              case S(_) | N =>
-                error(msg"Cannot use this ${ctor.describe} as a pattern" -> ctor.toLoc)
-                normalizeImpl(alternative)
-          case S(S(cls: (ClassSymbol | ModuleOrObjectSymbol))) if mode.isInstanceOf[MatchMode.StringPrefix] =>
-            // Match classes and modules are disallowed in the string mode.
-            normalizeImpl(alternative)
-          case S(S(cls: ClassSymbol)) =>
-            validateMatchMode(ctor, cls, mode)
-            if validateClassPattern(ctor, cls, ensureArguments(argsOpt)) then // TODO(ucs): deduplicate [1]
-              val whenTrue = aliasOutputSymbols(scrutinee, pattern.output,
-                normalize(specialize(consequent ++ alternative, +, scrutinee, pattern)))
-              val whenFalse = normalizeImpl(specialize(alternative, -, scrutinee, pattern).clearFallback)
-              Branch(scrutinee, pattern, whenTrue) ~: whenFalse
-            else // If any errors were raised, we skip the branch.
-              log("BROKEN"); normalizeImpl(alternative)
-          case S(S(mod: ModuleOrObjectSymbol)) =>
-            validateMatchMode(ctor, mod, mode)
-            if validateObjectPattern(pattern, mod, argsOpt) then // TODO(ucs): deduplicate [1]
-              val whenTrue = aliasOutputSymbols(scrutinee, pattern.output,
-                normalize(specialize(consequent ++ alternative, +, scrutinee, pattern)))
-              val whenFalse = normalizeImpl(specialize(alternative, -, scrutinee, pattern).clearFallback)
-              Branch(scrutinee, pattern, whenTrue) ~: whenFalse
-            else // If any errors were raised, we skip the branch.
-              log("BROKEN"); normalizeImpl(alternative)
-          case S(S(pat: PatternSymbol)) => mode match
-            // Note: `argsOpt` is supposed to be used in following cases, but
-            // the current implementation does not use it. The future version
-            // should properly handle the pattern arguments.
-            case MatchMode.Default =>
-              normalizeExtractorPattern(scrutinee, pat, ctor, argsOpt, pattern.output, consequent, normalizeImpl(alternative))
-            case sp: MatchMode.StringPrefix =>
-              normalizeStringPrefixPattern(scrutinee, ctor, argsOpt, sp, pattern.output, consequent, normalizeImpl(alternative))
-            case MatchMode.Annotated(annotation) => annotation.symbol match
-              case S(symbol) if symbol === ctx.builtins.annotations.compile =>
-                normalizeCompiledPattern(scrutinee, pat, ctor, argsOpt, pattern.output, consequent, normalizeImpl(alternative))
-              case S(_) =>
-                warn(msg"This annotation is not supported here." -> annotation.toLoc,
-                  msg"Note: Patterns (like `${pat.nme}`) only support the `@compile` annotation." -> N)
-                normalizeExtractorPattern(scrutinee, pat, ctor, argsOpt, pattern.output,consequent, normalizeImpl(alternative))
-              case N =>
-                // Name resolution should have already reported an error. We
-                // treat this as an extractor pattern.
-                normalizeExtractorPattern(scrutinee, pat, ctor, argsOpt, pattern.output, consequent, normalizeImpl(alternative))
+    case Split.Cons(Branch(scrutinee, pattern, consequent), alternative) =>
+      log(s"MATCH: ${scrutinee.showDbg} is ${pattern.showDbg}")
+      val whenTrue = normalize(specialize(consequent ++ alternative.duplicate, +, scrutinee, pattern))
+      val whenFalse = normalizeImpl(specialize(alternative, -, scrutinee, pattern).clearFallback)
+      Branch(scrutinee, pattern, whenTrue) ~: whenFalse
     case Split.Let(v, _, tail) if vs has v =>
       log(s"LET: SKIP already declared scrutinee $v")
       normalizeImpl(tail)
@@ -336,11 +264,11 @@ class Normalization(lowering: Lowering)(using tl: TL)(using Raise, Ctx, State) e
               mkMatch(mkArgs(clsParams.iterator.zip(args).toList))
             // Select the constructor's `.class` field.
             lazy val ctorTerm = ctor.symbol match
-              case S(mem: BlockMemberSymbol) =>
-                // If the class is declaration-only, we do not need to
-                // select the class.
-                if !mem.hasLiftedClass || mem.defn.exists(_.hasDeclareModifier.isDefined) then ctor
-                else Term.SynthSel(ctor, Tree.Ident("class"))(mem.clsTree.orElse(mem.modOrObjTree).map(_.symbol), N).resolve
+              // case S(mem: BlockMemberSymbol) =>
+              //   // If the class is declaration-only, we do not need to
+              //   // select the class.
+              //   if !mem.hasLiftedClass || mem.defn.exists(_.hasDeclareModifier.isDefined) then ctor
+              //   else Term.SynthSel(ctor, Tree.Ident("class"))(mem.clsTree.orElse(mem.modOrObjTree).map(_.symbol), N).resolve
               case _ => ctor
             symbol match
               case cls: ClassSymbol if ctx.builtins.virtualClasses contains cls =>

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

@@ -38,21 +38,23 @@ trait TermSynthesizer(using State):
 
   private lazy val runtimeRef: Term.Ref = State.runtimeSymbol.ref().resolve
 
-  /** Make a term that looks like `runtime.MatchResult` with its symbol. */
-  protected lazy val matchResultClass =
-    sel(runtimeRef, "MatchResult", State.matchResultClsSymbol).resolved(State.matchResultClsSymbol)
+  /** Make a term that looks like `runtime.MatchSuccess` with its symbol. */
+  protected lazy val matchSuccessClass =
+    sel(runtimeRef, "MatchSuccess", State.matchSuccessClsSymbol).resolved(State.matchSuccessClsSymbol)
 
-  /** Make a pattern that looks like `runtime.MatchResult.class`. */
-  protected def matchResultPattern(parameters: Opt[Ls[BlockLocalSymbol]]): FlatPattern.ClassLike =
-    FlatPattern.ClassLike(matchResultClass, parameters)
+  /** Make a pattern that looks like `runtime.MatchSuccess.class`. */
+  protected def matchSuccessPattern(parametersOpt: Opt[Ls[BlockLocalSymbol]]): FlatPattern.ClassLike =
+    val parameters = parametersOpt.map(_.map(_ -> N))
+    FlatPattern.ClassLike(matchSuccessClass, State.matchSuccessClsSymbol, parameters, false)(Tree.Dummy)
 
   /** Make a term that looks like `runtime.MatchFailure` with its symbol. */
   protected lazy val matchFailureClass =
     sel(runtimeRef, "MatchFailure", State.matchFailureClsSymbol).resolved(State.matchFailureClsSymbol)
 
   /** Make a pattern that looks like `runtime.MatchFailure.class`. */
-  protected def matchFailurePattern(parameters: Opt[Ls[BlockLocalSymbol]]): FlatPattern.ClassLike =
-    FlatPattern.ClassLike(matchFailureClass, parameters)
+  protected def matchFailurePattern(parametersOpt: Opt[Ls[BlockLocalSymbol]]): FlatPattern.ClassLike =
+    val parameters = parametersOpt.map(_.map(_ -> N))
+    FlatPattern.ClassLike(matchFailureClass, State.matchFailureClsSymbol, parameters, false)(Tree.Dummy)
 
   protected lazy val tupleSlice = sel(sel(runtimeRef, "Tuple"), "slice")
   protected lazy val tupleLazySlice = sel(sel(runtimeRef, "Tuple"), "lazySlice")
@@ -98,14 +100,14 @@ trait TermSynthesizer(using State):
     val s = TempSymbol(N, dbgName)
     Split.Let(s, cond, Branch(s.safeRef, inner) ~: Split.End)
 
-  protected final def makeMatchResult(output: Term) =
-    `new`(matchResultClass, tup(fld(output), fld(rcd())) :: Nil, "result of `MatchResult`")
+  protected final def makeMatchSuccess(output: Term) =
+    `new`(matchSuccessClass, tup(fld(output), fld(rcd())) :: Nil, "result of `MatchSuccess`")
 
-  protected final def makeMatchResult(output: Term, bindings: Term) =
-    `new`(matchResultClass, tup(fld(output), fld(bindings)) :: Nil, "result of `MatchResult`")
+  protected final def makeMatchSuccess(output: Term, bindings: Term) =
+    `new`(matchSuccessClass, tup(fld(output), fld(bindings)) :: Nil, "result of `MatchSuccess`")
 
-  protected final def makeMatchResult(output: Term, fields: Ls[RcdField | RcdSpread]) =
-    `new`(matchResultClass, tup(fld(output), fld(Term.Rcd(false, fields))) :: Nil, "result of `MatchResult`")
+  protected final def makeMatchSuccess(output: Term, fields: Ls[RcdField | RcdSpread]) =
+    `new`(matchSuccessClass, tup(fld(output), fld(Term.Rcd(false, fields))) :: Nil, "result of `MatchSuccess`")
 
   protected final def makeMatchFailure(errors: Term = Term.Lit(UnitLit(true))) =
     `new`(matchFailureClass, tup(fld(errors)) :: Nil, "result of `MatchFailure`")

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

@@ -159,7 +159,7 @@ class Instantiator(using tl: TL)(using Ctx, State, Raise):
       val shouldCompile = annotations.foldLeft(true): (acc, termOrLoc) =>
         val res = termOrLoc match
           case R(term) => term.resolvedSym match
-            case S(symbol) if symbol is ctx.builtins.annotations.compile => N
+            case S(symbol) if symbol.asBlkMember.exists(_ is ctx.builtins.annotations.compile) => N
             case S(_) | N => S(term.toLoc)
           case L(loc) => S(loc)
         res match

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

@@ -625,7 +625,7 @@ class SplitCompiler(using tl: TL)(using State, Ctx, Raise) extends TermSynthesiz
         val shouldCompile = annotations.foldLeft(true): (acc, termOrLoc) =>
           val res = termOrLoc match
             case R(term) => term.resolvedSym match
-              case S(symbol) if symbol is ctx.builtins.annotations.compile => N
+              case S(symbol) if symbol.asBlkMember.exists(_  is ctx.builtins.annotations.compile) => N
               case S(_) | N => S(term.toLoc)
             case L(loc) => S(loc)
           res match

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

@@ -110,7 +110,7 @@ case
 //│                 l = member:Foo
 //│                 disamb = S of class:Foo
 //│             _2 = Assign:
-//│               lhs = $param0
+//│               lhs = $argument0$
 //│               rhs = Select{sym=term:class:Foo.x}:
 //│                 qual = Ref:
 //│                   l = caseScrut
@@ -119,7 +119,7 @@ case
 //│               rest = Assign: \
 //│               lhs = a
 //│               rhs = Ref:
-//│                 l = $param0
+//│                 l = $argument0$
 //│                 disamb = N
 //│               rest = Return: \
 //│               res = Ref:

hkmc2/shared/src/test/mlscript/llir/nofib/scc.mls

@@ -3,8 +3,7 @@
 
 :import NofibPrelude.mls
 //│ Imported 104 member(s)
-//│ Error: hkmc2.ErrorReport: Unsupported kind of Call Call(Select(Select(Ref($runtime,None),Ident(Tuple)),Ident(get)),List(Arg(None,Ref(t1,None)), Arg(None,Lit(IntLit(0)))))
-//│ Stopped due to an error during the Llir generation
+//│ /!!!\ Uncaught error: scala.NotImplementedError: Label not supported (of class String)
 
 
 fun dfs(r, vsns, xs) = if vsns is [vs, ns] and
@@ -13,8 +12,7 @@ fun dfs(r, vsns, xs) = if vsns is [vs, ns] and
     x :: xs and
       inList(x, vs) then dfs(r, [vs, ns], xs)
       dfs(r, [x :: vs, Nil], r(x)) is [vs', ns'] then dfs(r, [vs', (x :: ns') +: ns], xs)
-//│ ═══[COMPILATION ERROR] Unsupported kind of Call Call(Select(Select(Ref($runtime,None),Ident(Tuple)),Ident(get)),List(Arg(None,Ref(vsns,None)), Arg(None,Lit(IntLit(0)))))
-//│ Stopped due to an error during the Llir generation
+//│ /!!!\ Uncaught error: scala.NotImplementedError: Label not supported (of class String)
 
 fun stronglyConnComp(es, vs) =
   fun swap(a) = if a is [f, s] then [s, f]

hkmc2/shared/src/test/mlscript/nofib/scc.mls

@@ -12,8 +12,7 @@ fun dfs(r, vsns, xs) = if vsns is [vs, ns] and
     x :: xs and
       inList(x, vs) then dfs(r, [vs, ns], xs)
       dfs(r, [x :: vs, Nil], r(x)) is [vs', ns'] then dfs(r, [vs', (x :: ns') +: ns], xs)
-//│ ═══[COMPILATION ERROR] Unsupported kind of Call Call(Select(Select(Ref($runtime,None),Ident(Tuple)),Ident(get)),List(Arg(None,Ref(vsns,None)), Arg(None,Lit(IntLit(0)))))
-//│ Stopped due to an error during the Llir generation
+//│ /!!!\ Uncaught error: scala.NotImplementedError: Label not supported (of class String)
 
 fun stronglyConnComp(es, vs) =
   fun swap(a) = if a is [f, s] then [s, f]