Separate module parameters from regular parameters

Module parameters are function parameters that have module identifiers as their type annotations. Module parameters must have an explicit and concrete type.

Author: FlandiaYingman

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

@@ -325,8 +325,12 @@ extends Importer:
   def fld(tree: Tree): Ctxl[Fld] = tree match
     case InfixApp(lhs, Keyword.`:`, rhs) =>
       Fld(FldFlags.empty, term(lhs), S(term(rhs)))
-    case _ => Fld(FldFlags.empty, term(tree), N)
-  
+    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)
+    
   def unit: Term.Lit = Term.Lit(UnitLit(true))
 
 
@@ -607,6 +611,8 @@ extends Importer:
     case InfixApp(lhs: Ident, Keyword.`:`, rhs) =>
       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
@@ -678,7 +684,7 @@ extends Importer:
   class VarianceTraverser(var changed: Bool = true) extends Traverser:
     override def traverseType(pol: Pol)(trm: Term): Unit = trm match
       case Term.TyApp(lhs, targs) =>
-        lhs.symbol.flatMap(_.asTpe) match
+        lhs.symbol.flatMap(sym => sym.asTpe orElse sym.asMod) match
           case S(sym: ClassSymbol) =>
             sym.defn match
             case S(td: ClassDef) =>
@@ -690,6 +696,17 @@ extends Importer:
                   if !tp.isCovariant then traverseType(pol.!)(targ)
             case N =>
               TODO(sym->sym.uid)
+          case S(sym: ModuleSymbol) =>
+            sym.defn match
+            case S(td: ModuleDef) =>
+              if td.tparams.sizeCompare(targs) =/= 0 then
+                raise(ErrorReport(msg"Wrong number of type arguments" -> trm.toLoc :: Nil)) // TODO BE
+              td.tparams.zip(targs).foreach:
+                case (tp, targ) =>
+                  if !tp.isContravariant then traverseType(pol)(targ)
+                  if !tp.isCovariant then traverseType(pol.!)(targ)
+            case N =>
+              TODO(sym->sym.uid)
           case S(sym: TypeAliasSymbol) =>
             // TODO dedup with above...
             sym.defn match

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

@@ -315,7 +315,9 @@ final case class Param(flags: FldFlags, sym: LocalSymbol & NamedSymbol, sign: Op
   // def showDbg: Str = flags.showDbg + sym.name + ": " + sign.showDbg
   def showDbg: Str = flags.showDbg + sym + sign.fold("")(": " + _.showDbg)
 
-object FldFlags { val empty: FldFlags = FldFlags(false, false, false) }
+object FldFlags { 
+  val empty: FldFlags = FldFlags(false, false, false, false)
+}
 
 final case class ParamListFlags(ctx: Bool):
   def showDbg: Str = (if ctx then "ctx " else "")

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

@@ -155,7 +155,7 @@ fun f2(m: M): Int = m.foo(42)
 //│           flags = ParamListFlags of false
 //│           params = Ls of 
 //│             Param:
-//│               flags = ()
+//│               flags = (module)
 //│               sym = m@42
 //│               sign = S of Sel:
 //│                 prefix = Ref of globalThis:block#1
@@ -296,30 +296,38 @@ id(IntMT)
 // Good: module parameters must have an explicit and concrete type. 
 // Mod[T] is a concrete type and Mod is a module, therefore t is a module parameter.
 fun idMod[T](t: MT[T]): MT[T] = t
-//│ FAILURE: Unexpected exception
-//│ /!!!\ Uncaught error: scala.NotImplementedError: an implementation is missing
-//│ 	at: scala.Predef$.$qmark$qmark$qmark(Predef.scala:344)
-//│ 	at: hkmc2.semantics.Elaborator$VarianceTraverser.traverseType(Elaborator.scala:708)
-//│ 	at: hkmc2.semantics.Elaborator$Traverser.traverseType$$anonfun$10(Elaborator.scala:750)
-//│ 	at: scala.runtime.function.JProcedure1.apply(JProcedure1.java:15)
-//│ 	at: scala.runtime.function.JProcedure1.apply(JProcedure1.java:10)
-//│ 	at: scala.Option.foreach(Option.scala:437)
-//│ 	at: hkmc2.semantics.Elaborator$Traverser.traverseType(Elaborator.scala:750)
-//│ 	at: hkmc2.semantics.Elaborator.go$4$$anonfun$1$$anonfun$1(Elaborator.scala:660)
-//│ 	at: scala.runtime.function.JProcedure1.apply(JProcedure1.java:15)
-//│ 	at: scala.runtime.function.JProcedure1.apply(JProcedure1.java:10)
+//│ Elaborated tree:
+//│ Blk:
+//│   stats = Ls of 
+//│     TermDefinition:
+//│       owner = S of globalThis:block#12
+//│       k = Fun
+//│       sym = member:idMod
+//│       params = Ls of 
+//│         ParamList:
+//│           flags = ParamListFlags of false
+//│           params = Ls of 
+//│             Param:
+//│               flags = (module)
+//│               sym = t@60
+//│               sign = S of Sel:
+//│                 prefix = Ref of globalThis:block#8
+//│                 nme = Ident of "MT"
+//│       sign = N
+//│       body = S of Ref of t@60
+//│       resSym = ‹result of member:idMod›@61
+//│       flags = ()
+//│   res = Lit of UnitLit of true
 
 // OK
 idMod(IntMT)
-//│ FAILURE: Unexpected type error
-//│ ╔══[ERROR] Name not found: idMod
-//│ ║  l.313: 	idMod(IntMT)
-//│ ╙──       	^^^^^
 //│ Elaborated tree:
 //│ Blk:
 //│   stats = Nil
 //│   res = App:
-//│     lhs = Error
+//│     lhs = Sel:
+//│       prefix = Ref of globalThis:block#12
+//│       nme = Ident of "idMod"
 //│     rhs = Tup of Ls of 
 //│       Fld:
 //│         flags = ()
@@ -344,7 +352,7 @@ fun f3(x: M) = x
 //│           flags = ParamListFlags of false
 //│           params = Ls of 
 //│             Param:
-//│               flags = ()
+//│               flags = (module)
 //│               sym = x@65
 //│               sign = S of Sel:
 //│                 prefix = Ref of globalThis:block#1