Prohibit access to non-val class parameters through pattern matching (#300)

Co-authored-by: Lionel Parreaux <lionel.parreaux@gmail.com>

Author: chengluyu

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

@@ -479,7 +479,7 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
                     case (param, arg) :: args =>
                       val (cse, blk) = mkArgs(args)
                       (cse, Assign(arg, Select(sr, param.id/*FIXME incorrect Ident?*/)(S(param)), blk))
-                  mkMatch(mkArgs(clsParams.zip(args)))
+                  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 Split.Else(els) =>
           if k.isInstanceOf[TailOp] && isIf then term_nonTail(els)(k)

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

@@ -7,10 +7,22 @@ import ucs.DeBrujinSplit
 
 /** Flat patterns for pattern matching */
 enum Pattern extends AutoLocated:
+  
   case Lit(literal: Literal)
-  case ClassLike(sym: ClassSymbol | ModuleSymbol, trm: Term, parameters: Opt[List[BlockLocalSymbol]], var refined: Bool)(val tree: Tree)
+  
+  /** An individual argument is None when it is not matched, i.e. when an underscore is used there.
+    * The whole argument list is None when no argument list is being matched at all, as in `x is Some then ...`. */
+  case ClassLike(
+    sym: ClassSymbol | ModuleSymbol,
+    trm: Term,
+    args: Opt[List[Opt[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
@@ -22,15 +34,16 @@ enum Pattern extends AutoLocated:
 
   def children: Ls[Located] = this match
     case Lit(literal) => literal :: Nil
-    case ClassLike(_, t, parameters, _) => t :: parameters.toList.flatten
+    case ClassLike(_, t, args, _) =>
+      t :: args.fold(Nil)(_.collect { case S(symbol) => symbol })
     case Synonym(_, arguments) => arguments.map(_.tree)
     case Tuple(fields, _) => Nil
     case Record(entries) => entries.flatMap { case (nme, als) => nme :: als :: Nil }
 
   def showDbg: Str = this match
     case Lit(literal) => literal.idStr
     case ClassLike(sym, t, ps, rfd) => (if rfd then "refined " else "") +
-      sym.nme + ps.fold("")(_.mkString("(", ", ", ")"))
+      sym.nme + ps.fold("")(_.iterator.map(_.fold("_")(_.toString)).mkString("(", ", ", ")"))
     case Synonym(symbol, arguments) =>
       symbol.nme + arguments.iterator.map(_.tree.showDbg).mkString("(", ", ", ")")
     case Tuple(size, inf) => "[]" + (if inf then ">=" else "=") + size

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

@@ -347,7 +347,7 @@ extension (split: DeBrujinSplit)
                   go(body, ctx2)
               val select = scoped("ucs:sel"):
                 elab.reference(symbol).getOrElse(Term.Error)
-              val pattern = Pattern.ClassLike(symbol, select, S(subSymbols), false)(Empty())
+              val pattern = Pattern.ClassLike(symbol, select, S(subSymbols.map(S.apply)), false)(Empty())
               semantics.Branch(ctx(scrutinee - 1)(), pattern, consequent2) ~: go(alternative, ctx)
             case ClassLike(ConstructorLike.Symbol(symbol: ModuleSymbol)) =>
               val select = scoped("ucs:sel"):

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

@@ -11,6 +11,7 @@ import Keyword.{as, and, `do`, `else`, is, let, `then`}
 import collection.mutable.{HashMap, SortedSet}
 import Elaborator.{ctx, Ctxl}
 import scala.annotation.targetName
+import hkmc2.semantics.ClassDef.Parameterized
 
 object Desugarer:
   extension (op: Keyword.Infix)
@@ -478,19 +479,27 @@ class Desugarer(val elaborator: Elaborator)
       val clsTrm = elaborator.cls(ctor, inAppPrefix = false)
       clsTrm.symbol.flatMap(_.asClsLike) match
       case S(cls: ClassSymbol) =>
-        val arity = cls.arity
-        if arity =/= args.length then
-          val m = args.length.toString
-          error:
-            if arity == 0 then
-              msg"the constructor does not take any arguments but found $m" -> app.toLoc
-            else
-              msg"mismatched arity: expect ${arity.toString}, found $m" -> app.toLoc
-        val params = scrutSymbol.getSubScrutinees(cls)
+        val paramSymbols = cls.defn match
+          case S(Parameterized(params = paramList)) =>
+            if paramList.params.size =/= args.length then
+              val n = args.length.toString
+              val m = paramList.params.size.toString
+              error:
+                if paramList.params.isEmpty then
+                  msg"the constructor does not take any arguments but found $n" -> app.toLoc
+                else
+                  msg"mismatched arity: expect $m, found $n" -> app.toLoc
+            scrutSymbol.getSubScrutinees(cls).iterator.zip(paramList.params).map:
+              case (symbol, Param(flags = FldFlags(value = true))) => R(symbol)
+              case (_, Param(_, paramSymbol, _)) => L(paramSymbol) // to report errors
+            .toList
+          case S(_) | N =>
+            error(msg"class ${cls.name} does not have parameters" -> ctor.toLoc)
+            Nil
         Branch(
           ref,
-          Pattern.ClassLike(cls, clsTrm, S(params), false)(ctor), // TODO: refined?
-          subMatches(params zip args, sequel)(Split.End)(ctx)
+          Pattern.ClassLike(cls, clsTrm, S(paramSymbols.map(_.toOption)), false)(ctor), // TODO: refined?
+          subMatches(paramSymbols.zip(args), sequel)(Split.End)(ctx)
         ) ~: fallback
       case S(pat: PatternSymbol) if compile =>
         // When we support extraction parameters, they need to be handled here.
@@ -550,26 +559,26 @@ class Desugarer(val elaborator: Elaborator)
         val (wrapRest, restMatches) = rest match
           case S((rest, last)) =>
             val (wrapLast, reversedLastMatches) = last.reverseIterator.zipWithIndex
-              .foldLeft[(Split => Split, Ls[(BlockLocalSymbol, Tree)])]((identity, Nil)):
+              .foldLeft[(Split => Split, Ls[(Right[Nothing, BlockLocalSymbol], Tree)])]((identity, Nil)):
                 case ((wrapInner, matches), (pat, lastIndex)) =>
                   val sym = scrutSymbol.getTupleLastSubScrutinee(lastIndex)
                   val wrap = (split: Split) =>
                     Split.Let(sym, callTupleGet(ref, -1 - lastIndex, sym), wrapInner(split))
-                  (wrap, (sym, pat) :: matches)
+                  (wrap, (R(sym), pat) :: matches)
             val lastMatches = reversedLastMatches.reverse
             rest match
               case N => (wrapLast, lastMatches)
               case S(pat) =>
                 val sym = TempSymbol(N, "rest")
                 val wrap = (split: Split) =>
                   Split.Let(sym, app(tupleSlice, tup(fld(ref), fld(int(lead.length)), fld(int(last.length))), sym), wrapLast(split))
-                (wrap, (sym, pat) :: lastMatches)
+                (wrap, (R(sym), pat) :: lastMatches)
           case N => (identity: Split => Split, Nil)
         val (wrap, matches) = lead.zipWithIndex.foldRight((wrapRest, restMatches)):
           case ((pat, i), (wrapInner, matches)) =>
             val sym = scrutSymbol.getTupleLeadSubScrutinee(i)
             val wrap = (split: Split) => Split.Let(sym, Term.SynthSel(ref, Ident(s"$i"))(N), wrapInner(split))
-            (wrap, (sym, pat) :: matches)
+            (wrap, (R(sym), pat) :: matches)
         Branch(
           ref,
           Pattern.Tuple(lead.length + rest.fold(0)(_._2.length), rest.isDefined),
@@ -609,16 +618,29 @@ class Desugarer(val elaborator: Elaborator)
   /** Desugar a list of sub-patterns (with their corresponding scrutinees).
    *  This is called when handling nested patterns. The caller is responsible
    *  for providing the symbols of scrutinees.
+   * 
+   *  @param matches a list of pairs consisting of a scrutinee and a pattern.
+   *    Each scrutinee is represented by `Either[VarSymbol, BlockLocalSymbol]`.
+   *    If it is not accessible due to the corresponding parameter not being
+   *    declared with `val`, it will be the `Left` of the parameter symbol for
+   *    error reporting.
+   *  @param sequel the innermost split
    */
-  def subMatches(matches: Ls[(BlockLocalSymbol, Tree)],
+  def subMatches(matches: Ls[(Either[VarSymbol, BlockLocalSymbol], Tree)],
                  sequel: Sequel): Split => Sequel = matches match
     case Nil => _ => ctx => trace(
       pre = s"subMatches (done) <<< Nil",
       post = (r: Split) => s"subMatches >>> ${r.showDbg}"
     ):
       sequel(ctx)
     case (_, Under()) :: rest => subMatches(rest, sequel)
-    case (scrutinee, pattern) :: rest => fallback => trace(
+    case (L(paramSymbol), pattern) :: rest =>
+      error(msg"This pattern cannot be matched" -> pattern.toLoc,
+        msg"because the corresponding parameter `${paramSymbol.name}` is not publicly accessible" -> paramSymbol.toLoc,
+        msg"Suggestion: use a wildcard pattern `_` in this position" -> N,
+        msg"Suggestion: mark this parameter with `val` so it becomes accessible" -> N)
+      subMatches(rest, sequel)
+    case (R(scrutinee), pattern) :: rest => fallback => trace(
       pre = s"subMatches (nested) <<< $scrutinee is $pattern",
       post = (r: Sequel) => s"subMatches (nested) >>>"
     ):

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

@@ -30,7 +30,7 @@ trait DesugaringBase(using state: State):
   protected def matchResultPattern(parameters: Opt[List[BlockLocalSymbol]]): Ctxl[Pattern.ClassLike] =
     val (classRef, classSym) = matchResultClass
     val classSel = Term.SynthSel(classRef, Ident("class"))(S(classSym))
-    Pattern.ClassLike(classSym, classSel, parameters, false)(Empty())
+    Pattern.ClassLike(classSym, classSel, parameters.map(_.map(S.apply)), false)(Empty())
 
   /** Make a term that looks like `runtime.MatchFailure` with its symbol. */
   protected lazy val matchFailureClass: Ctxl[(Term.Sel | Term.SynthSel, ClassSymbol)] =
@@ -40,7 +40,7 @@ trait DesugaringBase(using state: State):
   protected def matchFailurePattern(parameters: Opt[List[BlockLocalSymbol]]): Ctxl[Pattern.ClassLike] =
     val (classRef, classSym) = matchResultClass
     val classSel = Term.SynthSel(classRef, Ident("class"))(S(classSym))
-    Pattern.ClassLike(classSym, classSel, parameters, false)(Empty())
+    Pattern.ClassLike(classSym, classSel, parameters.map(_.map(S.apply)), false)(Empty())
 
   protected lazy val tupleSlice = sel(sel(state.runtimeSymbol.ref(), "Tuple"), "slice")
   protected lazy val tupleGet = sel(sel(state.runtimeSymbol.ref(), "Tuple"), "get")

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

@@ -46,7 +46,7 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
     def =:=(rhs: Pattern): Bool = (lhs, rhs) match
       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 (Pattern.Tuple(n1, b1), Pattern.Tuple(n2, b2)) => n1 === n2 && b1 === b2
       case (_, _) => false
     /** Checks if `lhs` can be subsumed under `rhs`. */
     def <:<(rhs: Pattern): Bool = compareCasePattern(lhs, rhs)
@@ -223,8 +223,9 @@ class Normalization(elaborator: Elaborator)(using raise: Raise, ctx: Ctx):
   private def aliasBindings(p: Pattern, q: Pattern): Split => Split = (p, q) match
     case (Pattern.ClassLike(_, _, S(ps1), _), Pattern.ClassLike(_, _, S(ps2), _)) =>
       ps1.iterator.zip(ps2.iterator).foldLeft(identity[Split]):
-        case (acc, (p1, p2)) if p1 == p2 => acc
-        case (acc, (p1, p2)) => innermost => Split.Let(p2, p1.ref(), acc(innermost))
+        case (acc, (S(p1), S(p2))) if p1 === p2 => acc
+        case (acc, (S(p1), S(p2))) => innermost => Split.Let(p2, p1.ref(), acc(innermost))
+        case (acc, (_, _)) => acc
     case (_, _) => identity
 end Normalization
 
@@ -240,7 +241,7 @@ object Normalization:
     case (ClassLike(cs: ClassSymbol, _, _, _), ClassLike(blt.`Object`, _, _, _))
         if !ctx.builtins.virtualClasses.contains(cs) => true
     case (ClassLike(cs: ModuleSymbol, _, _, _), ClassLike(blt.`Object`, _, _, _)) => true
-    case (Tuple(n1, false), Tuple(n2, false)) if n1 == n2 => true
+    case (Tuple(n1, false), Tuple(n2, false)) if n1 === n2 => true
     case (Tuple(n1, _), Tuple(n2, true)) if n2 <= n1 => true
     case (ClassLike(`Int`, _, _, _), ClassLike(blt.`Num`, _, _, _)) => true
     // case (s1: ClassSymbol, s2: ClassSymbol) => s1 <:< s2 // TODO: find a way to check inheritance

hkmc2/shared/src/test/mlscript-compile/XML.mjs

@@ -6,11 +6,10 @@ StyleAttributeValue1 = function StyleAttributeValue(rules1) {
   return new StyleAttributeValue.class(rules1);
 };
 StyleAttributeValue1.class = class StyleAttributeValue {
-  #rules;
   constructor(rules) {
-    this.#rules = rules;
+    this.rules = rules;
   }
-  toString() { return "StyleAttributeValue(" + "" + ")"; }
+  toString() { return "StyleAttributeValue(" + globalThis.Predef.render(this.rules) + ")"; }
 };
 (class XML {
   static {

hkmc2/shared/src/test/mlscript-compile/XML.mls

@@ -5,7 +5,7 @@ open Predef
 open Iter { mapping, joined }
 
 
-class StyleAttributeValue(rules)
+data class StyleAttributeValue(rules)
 
 
 module XML with ...

hkmc2/shared/src/test/mlscript/backlog/ToTriage.mls

@@ -394,21 +394,33 @@ Foo(1, 2, 3).args
 
 :todo
 if Foo(1, 2, 3) is Foo(...args) then args
-//│ ╔══[ERROR] Unrecognized pattern (spread)
+//│ ╔══[ERROR] the constructor does not take any arguments but found 1
 //│ ║  l.396: 	if Foo(1, 2, 3) is Foo(...args) then args
-//│ ╙──       	                          ^^^^
+//│ ╙──       	                   ^^^^^^^^^^^^
+//│ ╔══[ERROR] Name not found: args
+//│ ║  l.396: 	if Foo(1, 2, 3) is Foo(...args) then args
+//│ ╙──       	                                     ^^^^
 //│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
 
 if Foo(1, 2, 3) is Foo(a, b, c) then [a, b, c]
-//│ ╔══[ERROR] mismatched arity: expect 1, found 3
-//│ ║  l.402: 	if Foo(1, 2, 3) is Foo(a, b, c) then [a, b, c]
+//│ ╔══[ERROR] the constructor does not take any arguments but found 3
+//│ ║  l.405: 	if Foo(1, 2, 3) is Foo(a, b, c) then [a, b, c]
 //│ ╙──       	                   ^^^^^^^^^^^^
+//│ ╔══[ERROR] Name not found: a
+//│ ║  l.405: 	if Foo(1, 2, 3) is Foo(a, b, c) then [a, b, c]
+//│ ╙──       	                                      ^
 //│ ╔══[ERROR] Name not found: b
-//│ ║  l.402: 	if Foo(1, 2, 3) is Foo(a, b, c) then [a, b, c]
+//│ ║  l.405: 	if Foo(1, 2, 3) is Foo(a, b, c) then [a, b, c]
 //│ ╙──       	                                         ^
 //│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
 
 if Foo(1, 2, 3) is Foo(arg) then arg
+//│ ╔══[ERROR] the constructor does not take any arguments but found 1
+//│ ║  l.417: 	if Foo(1, 2, 3) is Foo(arg) then arg
+//│ ╙──       	                   ^^^^^^^^
+//│ ╔══[ERROR] Name not found: arg
+//│ ║  l.417: 	if Foo(1, 2, 3) is Foo(arg) then arg
+//│ ╙──       	                                 ^^^
 //│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
 
 // ——— ——— ———

hkmc2/shared/src/test/mlscript/backlog/UCS.mls

@@ -111,7 +111,7 @@ if 1 + 1
 
 // ——— ——— ———
 
-class Some(v)
+class Some(val v)
 
 Some(1) is
   Some of [process, rest] do "hi"
@@ -122,6 +122,7 @@ Some(1) is
 
 // ——— ——— ———
 
+class Some(val v)
 object None
 
 // :ucs normalized
@@ -159,31 +160,21 @@ fun parse(text: Str): [Int, Str] =
 
 // ——— ——— ———
 
-class
-  Tuple(a, b, c)
-  Ident(n)
-
-fun foo(tree) =
-  fun go(x) = ???
-  if tree is
-    Tuple(category, choice, function) and
-      category is Ident(categoryName) and
-        function is Ident(functionName) and
-          choice is
-            Tuple(elements) then Some(go(elements))
-            other then Some(go(other))
-        else
-          console.warn("expect the choice to be a bracketed term but found " + choice)
-          None
-      else
-        console.warn("expect a the category to be an identifier but found " + category)
-        None
-    else
-      console.warn("expect the definition to be a tuple but found " + tree)
-      None
+data class Tuple(a, b, c)
+
+let foo =
+  case
+    Tuple(...elements) then elements
 //│ ╔══[ERROR] mismatched arity: expect 3, found 1
-//│ ║  l.173: 	            Tuple(elements) then Some(go(elements))
-//│ ╙──       	            ^^^^^^^^^^^^^^^
+//│ ║  l.167: 	    Tuple(...elements) then elements
+//│ ╙──       	    ^^^^^^^^^^^^^^^^^^
+//│ ╔══[ERROR] Unrecognized pattern (spread)
+//│ ║  l.167: 	    Tuple(...elements) then elements
+//│ ╙──       	             ^^^^^^^^
+//│ foo = [function]
+
+foo(Tuple(1, 2, 3))
+//│ ═══[RUNTIME ERROR] Error: match error
 
 // ——— ——— ———
 
@@ -196,28 +187,28 @@ fun foo(x) = if x is Foo.
   Bar then "Bar"
   Foo then "Foo"
 //│ ╔══[ERROR] Unrecognized pattern split.
-//│ ║  l.195: 	fun foo(x) = if x is Foo.
+//│ ║  l.186: 	fun foo(x) = if x is Foo.
 //│ ╙──       	                     ^^^
 //│ ╔══[ERROR] Cannot use this identifier as an extractor
-//│ ║  l.195: 	fun foo(x) = if x is Foo.
+//│ ║  l.186: 	fun foo(x) = if x is Foo.
 //│ ╙──       	                        ^
 //│ ╔══[ERROR] Cannot use this identifier as an extractor
-//│ ║  l.195: 	fun foo(x) = if x is Foo.
+//│ ║  l.186: 	fun foo(x) = if x is Foo.
 //│ ╙──       	                        ^
 
 fun foo(x) = if x is Foo
   .Bar then "Bar"
   .Foo then "Foo"
 //│ ╔══[PARSE ERROR] Expected an expression; found selector instead
-//│ ║  l.209: 	  .Bar then "Bar"
+//│ ║  l.200: 	  .Bar then "Bar"
 //│ ╙──       	  ^^^^
 //│ ╔══[PARSE ERROR] Unexpected selector here
-//│ ║  l.209: 	  .Bar then "Bar"
+//│ ║  l.200: 	  .Bar then "Bar"
 //│ ╙──       	  ^^^^
 //│ ╔══[ERROR] Unrecognized pattern split.
-//│ ║  l.208: 	fun foo(x) = if x is Foo
+//│ ║  l.199: 	fun foo(x) = if x is Foo
 //│ ║         	                     ^^^
-//│ ║  l.209: 	  .Bar then "Bar"
+//│ ║  l.200: 	  .Bar then "Bar"
 //│ ╙──       	^^
 
 // ——— ——— ———

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

@@ -77,8 +77,8 @@ case
 //│             trm = SynthSel{class:Foo}:
 //│               prefix = Ref of member:Foo
 //│               nme = Ident of "class"
-//│             parameters = S of Ls of 
-//│               $param0
+//│             args = S of Ls of 
+//│               S of $param0
 //│             refined = false
 //│           continuation = Let:
 //│             sym = a

hkmc2/shared/src/test/mlscript/ucs/hygiene/CrossBranchCapture.mls

@@ -25,7 +25,7 @@ process(Numb(1), 10)
 
 
 // class Vec(xs: Array[Numb | Vec]) // Array is not available
-abstract class Vec[out T](n: Int)
+data abstract class Vec[out T](n: Int)
 data class Cons[out T](head: T, tail: Vec[T]) extends Vec[T]
 module Nil extends Vec[Nothing]