Enforce rules on module arguments

Author: FlandiaYingman

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

@@ -232,7 +232,34 @@ extends Importer:
       term(rhs)
     case tree @ App(lhs, rhs) =>
       val sym = FlowSymbol("‹app-res›", nextUid)
-      Term.App(term(lhs), term(rhs))(tree, sym)
+      val lt = term(lhs)
+      val rt = term(rhs)
+
+      // Check if module arguments match module parameters
+      val args = rt match
+        case Term.Tup(fields) => S(fields)
+        case _ => N
+      val params = lt.symbol
+        .collect:
+          case sym: BlockMemberSymbol => sym.trmTree
+        .flatten
+        .collect:
+          case td: TermDef => td.paramLists.headOption
+        .flatten
+      for
+        (args, params) <- (args zip params)
+        (arg, param) <- (args zip params.fields)
+      do 
+        val argMod = arg.flags.mod
+        val paramMod = param match
+          case Tree.TypeDef(Mod, _, N, N) => true
+          case _ => false
+        if argMod && !paramMod then raise:
+          ErrorReport:
+            msg"Only module parameters may receive module arguments (values)." -> 
+            arg.toLoc :: Nil
+      
+      Term.App(lt, rt)(tree, sym)
     case Sel(pre, nme) =>
       val preTrm = term(pre)
       val sym = resolveField(nme, preTrm.symbol, nme)
@@ -329,9 +356,10 @@ extends Importer:
       Fld(FldFlags.empty, term(lhs), S(term(rhs)))
     case _ => 
       val t = term(tree)
-      t.symbol.flatMap(_.asMod) match
-        case S(_) => Fld(FldFlags.empty.copy(mod = true), t, N)
-        case N => Fld(FldFlags.empty, t, N)
+      val flags = FldFlags.empty
+      if ModuleChecker.evalsToModule(t) 
+      then Fld(flags.copy(mod = true), t, N)
+      else Fld(flags, t, N)
 
   def unit: Term.Lit = Term.Lit(UnitLit(true))
 

hkmc2/shared/src/test/mlscript/basics/ModuleMethods.mls

@@ -6,53 +6,64 @@ class C with {
 module M with {
   // module method foo
   fun foo(x) = x
+  fun self(): module M = M
 }
 
 :e
 fun f1(module m)
 //│ ╔══[ERROR] Module parameters must have explicit types.
-//│ ║  l.12: 	fun f1(module m)
+//│ ║  l.13: 	fun f1(module m)
 //│ ╙──      	              ^
 
 :e
 fun f2[T](module m: T)
 //│ ╔══[ERROR] Module parameters must have concrete types.
-//│ ║  l.18: 	fun f2[T](module m: T)
+//│ ║  l.19: 	fun f2[T](module m: T)
 //│ ╙──      	                 ^^^^
 
 :e
 module N with {
   fun f3(): M = M
 }
 //│ ╔══[ERROR] The return type of functions returning module values must be prefixed with module keyword.
-//│ ║  l.25: 	  fun f3(): M = M
+//│ ║  l.26: 	  fun f3(): M = M
 //│ ╙──      	      ^^^^^^^
 
 :e
 module N with {
   fun f4[T](): module T = M
 }
 //│ ╔══[ERROR] Function returning module values must have concrete return types.
-//│ ║  l.33: 	  fun f4[T](): module T = M
+//│ ║  l.34: 	  fun f4[T](): module T = M
 //│ ╙──      	      ^^^^^^^^^^^^^^^^^
 
 :e
 module N with {
   fun f5(): M = M
 }
 //│ ╔══[ERROR] The return type of functions returning module values must be prefixed with module keyword.
-//│ ║  l.41: 	  fun f5(): M = M
+//│ ║  l.42: 	  fun f5(): M = M
 //│ ╙──      	      ^^^^^^^
 
+
+fun f6(m: M)
+
 :e
-fun f6(module m: M)
-f6(new C)
-//│ FAILURE: Unexpected lack of type error
+f6(M)
+//│ ╔══[ERROR] Only module parameters may receive module arguments (values).
+//│ ║  l.52: 	f6(M)
+//│ ╙──      	   ^
+
+:e
+f6(M.self())
+//│ ╔══[ERROR] Only module parameters may receive module arguments (values).
+//│ ║  l.58: 	f6(M.self())
+//│ ╙──      	   ^^^^^^^^
 
 :e
 fun f7(): module M
 //│ ╔══[ERROR] Only module methods may return module values.
-//│ ║  l.53: 	fun f7(): module M
+//│ ║  l.64: 	fun f7(): module M
 //│ ╙──      	    ^^^^^^^^^^^^^^
 
 
@@ -63,3 +74,5 @@ module N with {
 }
 
 ok1(M)
+
+ok1(M.self())