address comments

Author: FlandiaYingman

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

@@ -235,28 +235,31 @@ extends Importer:
       val lt = term(lhs)
       val rt = term(rhs)
 
-      // Check module parameters
+      // Check if module arguments match module parameters
       val args = rt match
         case Term.Tup(fields) => S(fields)
         case _ => N
-      val argsModFlags = args
-        .map(_.map(_.flags.mod))
-      val paramsModFlags = lt.symbol match
-        case S(sym: BlockMemberSymbol) => sym.defn match
-          case S(defn: TermDefinition) => defn.params.lift(0)
-            .map(_.params.map(_.flags.mod))
-          case _ => argsModFlags.map(_.map(_ => false))
-        case _ => argsModFlags.map(_.map(_ => false))
+      val params = lt.symbol
+        .filter(_.isInstanceOf[BlockMemberSymbol])
+        .flatMap(_.asInstanceOf[BlockMemberSymbol].trmTree)
+        .filter(_.isInstanceOf[TermDef])
+        .flatMap(_.asInstanceOf[TermDef].paramLists.headOption)
       for
-        (argLists, amfs, pmfs) <- (args lazyZip argsModFlags lazyZip paramsModFlags)
-        (a, amf, pmf) <- (argLists lazyZip amfs lazyZip pmfs)
-        if amf && !pmf
+        (args, params) <- (args zip params)
+        (arg, param) <- (args zip params.fields)
       do 
-        log(s"${a.value}")
-        raise(ErrorReport(
-        msg"Module values can only be passed to module parameters." -> a.toLoc
-        :: Nil, 
-      ))
+        val argMod = arg.flags.mod
+        val paramMod = param match
+          case Tree.TypeDef(Mod, _, _, _) => true
+          case _ => false
+        if argMod && !paramMod then
+          raise:
+            ErrorReport:
+              msg"Module values can only be passed to module parameters." -> arg.toLoc :: Nil
+        if !argMod && paramMod then
+          raise:
+            ErrorReport:
+              msg"Module parameters can only receive module values." -> arg.toLoc :: Nil
 
       Term.App(lt, rt)(tree, sym)
     case Sel(pre, nme) =>
@@ -354,7 +357,7 @@ extends Importer:
     case _ => 
       val t = term(tree)
       t.symbol.flatMap(_.asMod) match
-        case S(_) => Fld(FldFlags.module, t, N)
+        case S(_) => Fld(FldFlags.empty.copy(mod = true), t, N)
         case N => Fld(FldFlags.empty, t, N)
 
   def unit: Term.Lit = Term.Lit(UnitLit(true))
@@ -652,24 +655,10 @@ extends Importer:
     case id: Ident =>
       Param(FldFlags.empty, fieldOrVarSym(ParamBind, id), N) :: Nil
     case InfixApp(lhs: Ident, Keyword.`:`, rhs) =>
-      // return S(moduleParam) if t represents a module parameter
-      // return N otherwise
-      def moduleParam(t: Term): Opt[Param] = t match
-        case s: hkmc2.semantics.Term.Sel => s.symbol
-          .flatMap(_.asMod)
-          .map(_ => Param(FldFlags.module, fieldOrVarSym(ParamBind, lhs), S(s)))
-        case hkmc2.semantics.Term.TyApp(s: hkmc2.semantics.Term.Sel, _) => s.symbol
-          .flatMap(_.asMod)
-          .map(_ => Param(FldFlags.module, fieldOrVarSym(ParamBind, lhs), S(s)))
-        case _ => N
-      
-      val t = term(rhs)
-      moduleParam(t) match
-        case S(p) => 
-          p :: Nil
-        case N =>
-          Param(FldFlags.empty, fieldOrVarSym(ParamBind, lhs), S(term(rhs))) :: Nil
+      Param(FldFlags.empty, fieldOrVarSym(ParamBind, lhs), S(term(rhs))) :: Nil
     case App(Ident(","), list) => params(list)._1
+    case TypeDef(Mod, inner, _, _) => param(inner)
+      .map(p => p.copy(flags = p.flags.copy(mod = true)))
     case TermDef(ImmutVal, inner, _) => param(inner)
 
   def params(t: Tree): Ctxl[(Ls[Param], Ctx)] = t match

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

@@ -3,6 +3,7 @@ package semantics
 
 import mlscript.utils.*, shorthands.*
 import syntax.*
+import scala.collection.mutable.Buffer
 
 
 final case class QuantVar(sym: VarSymbol, ub: Opt[Term], lb: Opt[Term])
@@ -187,10 +188,10 @@ final case class LetDecl(sym: LocalSymbol) extends Statement
 final case class DefineVar(sym: LocalSymbol, rhs: Term) extends Statement
 
 final case class TermDefFlags(mod: Bool):
-  def showDbg: Str = (
-    (if mod then S("module") else N) ::
-    Nil
-  ).flatten.mkString(" ")
+  def showDbg: Str = 
+    val flags = Buffer.empty[String]
+    if mod then flags += "module"
+    flags.mkString(" ")
   override def toString: String = "‹" + showDbg + "›"
 
 object TermDefFlags { val empty: TermDefFlags = TermDefFlags(false) }
@@ -284,7 +285,13 @@ 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):
-  def showDbg: Str = (if mut then "mut " else "") + (if spec then "spec " else "") + (if genGetter then "val " else "") + (if mod then "mod " else "")
+  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"
+    flags.mkString(" ")
   override def toString: String = "‹" + showDbg + "›"
 
 final case class Fld(flags: FldFlags, value: Term, asc: Opt[Term]) extends FldImpl
@@ -310,10 +317,7 @@ final case class Param(flags: FldFlags, sym: LocalSymbol & NamedSymbol, sign: Op
 
 object FldFlags { 
   val empty: FldFlags = FldFlags(false, false, false, false)
-
-  // module parameter / module argument, depending on the context
-  val module: FldFlags = FldFlags(false, false, false, true)
- }
+}
 
 final case class ParamListFlags(ctx: Bool):
   def showDbg: Str = (if ctx then "ctx " else "")

hkmc2/shared/src/main/scala/hkmc2/utils/utils.scala

@@ -40,14 +40,14 @@ extension (t: Product)
       case TermDefFlags(mod) =>
         val flags = Buffer.empty[String]
         if mod then flags += "module"
-        if flags.isEmpty then "()" else flags.mkString("(", ", ", ")")
+        flags.mkString("(", ", ", ")")
       case FldFlags(mut, spec, genGetter, mod) =>
         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 flags.isEmpty then "()" else flags.mkString("(", ", ", ")")
+        flags.mkString("(", ", ", ")")
       case t: Product => t.showAsTree(inTailPos)
       case v => v.toString
     val postfix = post(t)