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

@@ -605,7 +605,23 @@ extends Importer:
     case id: Ident =>
       Param(FldFlags.empty, fieldOrVarSym(ParamBind, id), N) :: Nil
     case InfixApp(lhs: Ident, Keyword.`:`, rhs) =>
-      Param(FldFlags.empty, fieldOrVarSym(ParamBind, lhs), S(term(rhs))) :: Nil
+      // 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
     case App(Ident(","), list) => params(list)._1
     case TermDef(ImmutVal, inner, _) => param(inner)
 
@@ -678,7 +694,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 +706,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

@@ -283,8 +283,8 @@ case class TypeDef(
 
 
 // TODO Store optional source locations for the flags instead of booleans
-final case class FldFlags(mut: Bool, spec: Bool, genGetter: Bool):
-  def showDbg: Str = (if mut then "mut " else "") + (if spec then "spec " else "") + (if genGetter then "val " else "")
+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 "")
   override def toString: String = "‹" + showDbg + "›"
 
 final case class Fld(flags: FldFlags, value: Term, asc: Opt[Term]) extends FldImpl
@@ -308,7 +308,12 @@ 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)
+
+  // module parameter
+  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

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

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