Changes from meeting

Author: LPTK

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

@@ -200,12 +200,12 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         WarningReport(msg"Pure expression in statement position" -> t.toLoc :: Nil, S(t))
 
     val withImplicitApp = t match
-      case t: sem.ImplicitApp => t.instantiate
+      case t: sem.PossiblyImplicitApp => t.instantiate
       case t => t
 
     // Funny Scala: the non-exhaustive match is actually the second match
     t match
-      case t: sem.ImplicitApp => t.instantiate
+      case t: sem.PossiblyImplicitApp => t.instantiate
       case t => t
     match
     case st.UnitVal() => k(unit)

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

@@ -124,20 +124,20 @@ class Resolver(tl: TraceLogger)
     case NonModule(reason: Opt[Message])
     case Any
 
-  extension (e: Expect)
-    def message: Ls[Message -> Opt[Loc]] = e match
+    def message: Ls[Message -> Opt[Loc]] = this match
       case Expect.Module(msg) => msg.toList.map(_ -> N)
       case Expect.NonModule(msg) => msg.toList.map(_ -> N)
       case Expect.Any => Nil
 
-    def module = e match
+    def module = this match
       case Expect.Module(_) => true
       case _ => false
 
-    def nonModule = e match
+    def nonModule = this match
       case Expect.NonModule(_) => true
       case _ => false
-  
+    
+  end Expect
   import Expect.*
 
   /** 
@@ -172,16 +172,16 @@ class Resolver(tl: TraceLogger)
       case t: Term.IfLike =>
         t.subTerms.foreach(resolve(_, expect = Any))
 
-      case t: ImplicitApp =>
+      case t: PossiblyImplicitApp =>
         resolveImplicitApp(t)
 
       case _ => 
         t.subTerms.foreach(resolve(_, expect = NonModule(N)))
 
   def resolveSymbol(t: Term.Sel | Term.SynthSel)(using ictx: ICtx): Unit =
     val (lhs, id) = t match
-      case Term.Sel(lhs: ImplicitApp, id) => (lhs, id)
-      case Term.SynthSel(lhs: ImplicitApp, id) => (lhs, id)
+      case Term.Sel(lhs: PossiblyImplicitApp, id) => (lhs, id)
+      case Term.SynthSel(lhs: PossiblyImplicitApp, id) => (lhs, id)
       case _ => return
     lhs.termDefn match
       case S(lhsDefn) =>
@@ -212,15 +212,15 @@ class Resolver(tl: TraceLogger)
               lastWords(s"term ${lhs} returns module but has no type signature")
       case N =>
 
-  def resolveImplicitApp(t: Term & ImplicitApp, inPrefix: Bool = false)(using ICtx): (Opt[TermDefinition], ICtx) =
+  def resolveImplicitApp(t: Term & PossiblyImplicitApp, inPrefix: Bool = false)(using ICtx): (Opt[TermDefinition], ICtx) =
   trace[(Opt[TermDefinition], ICtx)](s"Resolving implicit application: ${t}, (inPrefix = ${inPrefix})", _ => s"~> ${t}"):
     val (defn, newICtx1) = t match
-      case Term.App(lhs: ImplicitApp, _) =>
+      case Term.App(lhs: PossiblyImplicitApp, _) =>
         resolveImplicitApp(lhs)
       case Term.App(lhs: Term, args) =>
         resolve(lhs, expect = Any)
         (t.termDefn, ictx)
-      case Term.TyApp(lhs: ImplicitApp, targs) =>
+      case Term.TyApp(lhs: PossiblyImplicitApp, targs) =>
         resolveImplicitApp(lhs, inPrefix = true)
         (t.termDefn, ictx)
       case Term.TyApp(lhs: Term, targs) =>

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

@@ -28,7 +28,7 @@ enum Annot extends AutoLocated:
     case Trm(trm) => trm :: Nil
     case _: Modifier | Untyped => Nil
 
-sealed trait ImplicitApp:
+sealed trait PossiblyImplicitApp:
   t: Term =>
 
   var argsLs: Ls[Term.Tup] = Nil
@@ -68,11 +68,11 @@ enum Term extends Statement:
   case Missing // Placeholder terms that were not elaborated due to the "lightweight" elaboration mode `Mode.Light`
   case Lit(lit: Literal)
   case Builtin(id: Tree.Ident, nme: Str)
-  case Ref(sym: Symbol)(val tree: Tree.Ident, val refNum: Int) extends Term with ImplicitApp
-  case App(lhs: Term, rhs: Term)(val tree: Tree.App, val resSym: FlowSymbol) extends Term with ImplicitApp
-  case TyApp(lhs: Term, targs: Ls[Term]) extends Term with ImplicitApp
-  case Sel(prefix: Term, nme: Tree.Ident)(var sym: Opt[FieldSymbol]) extends Term with ImplicitApp
-  case SynthSel(prefix: Term, nme: Tree.Ident)(var sym: Opt[FieldSymbol]) extends Term with ImplicitApp
+  case Ref(sym: Symbol)(val tree: Tree.Ident, val refNum: Int) extends Term with PossiblyImplicitApp
+  case App(lhs: Term, rhs: Term)(val tree: Tree.App, val resSym: FlowSymbol) extends Term with PossiblyImplicitApp
+  case TyApp(lhs: Term, targs: Ls[Term]) extends Term with PossiblyImplicitApp
+  case Sel(prefix: Term, nme: Tree.Ident)(var sym: Opt[FieldSymbol]) extends Term with PossiblyImplicitApp
+  case SynthSel(prefix: Term, nme: Tree.Ident)(var sym: Opt[FieldSymbol]) extends Term with PossiblyImplicitApp
   case DynSel(prefix: Term, fld: Term, arrayIdx: Bool)
   case Tup(fields: Ls[Elem])(val tree: Tree.Tup)
   case IfLike(kw: Keyword.`if`.type | Keyword.`while`.type, desugared: Split)(val normalized: Split)

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

@@ -25,7 +25,7 @@ import hkmc2.semantics.FldFlags
 import hkmc2.semantics.ParamListFlags
 import scala.collection.mutable.Buffer
 import mlscript.utils.StringOps
-import hkmc2.semantics.ImplicitApp
+import hkmc2.semantics.PossiblyImplicitApp
 
 trait ProductWithTail extends Product
 
@@ -81,9 +81,9 @@ extension (t: Product)
       case a =>
         var args = t.productIterator.zipWithIndex.map:
           case (v, i) => t.productElementName(i) + " = " + aux(v, t.isInstanceOf[ProductWithTail] && i === a - 1)
-        if t.isInstanceOf[ImplicitApp] then
+        if t.isInstanceOf[PossiblyImplicitApp] then
           args = args ++ Iterator:
-            "ImplicitArgs = " + aux(t.asInstanceOf[ImplicitApp].argsLs)
+            "ImplicitArgs = " + aux(t.asInstanceOf[PossiblyImplicitApp].argsLs)
         prefix + locally:
           if inTailPos then ": \\\n" + args.mkString("\n")
           else ":\n" + args.mkString("\n").indent("  ")

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

@@ -157,7 +157,7 @@ val v: module M = M
 
 
 
-// "Module" Methods
+// *Module* Methods
 
 module N with
   fun foo(): module M = M

hkmc2/shared/src/test/mlscript/ctx/CascadingTypeClasses.mls

@@ -11,21 +11,24 @@ fun foo[A](using Foo[A], A)
 use Foo[Baz] = new Foo
 
 
-:todo
+// FIXME: error message refers to `A`
+:e
+:fixme // Internal Error should never reach users
 foo[Baz]
 //│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
-//│ ║  l.15: 	foo[Baz]
+//│ ║  l.17: 	foo[Baz]
 //│ ║        	^^^^^^^
 //│ ╟── Required by contextual parameter declaration: 
 //│ ║  l.9: 	fun foo[A](using Foo[A], A)
 //│ ║       	                         ^
 //│ ╙── Expected: A; Available: (Foo[Baz])
 //│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
 
-:todo
+:e
+:fixme // Internal Error should never reach users
 foo
 //│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
-//│ ║  l.26: 	foo
+//│ ║  l.29: 	foo
 //│ ║        	^^^
 //│ ╟── Required by contextual parameter declaration: 
 //│ ║  l.9: 	fun foo[A](using Foo[A], A)
@@ -34,17 +37,31 @@ foo
 //│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
 
 
+use Baz = new Baz
+
+:todo
+foo
+//│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
+//│ ║  l.43: 	foo
+//│ ║        	^^^
+//│ ╟── Required by contextual parameter declaration: 
+//│ ║  l.9: 	fun foo[A](using Foo[A], A)
+//│ ║       	                         ^
+//│ ╙── Expected: A; Available: (Foo[Baz], Baz)
+//│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
+
+
 fun foo[A](using Foo[A])(using A)
 
 :todo
 foo
 //│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
-//│ ║  l.40: 	foo
+//│ ║  l.57: 	foo
 //│ ║        	^^^
 //│ ╟── Required by contextual parameter declaration: 
-//│ ║  l.37: 	fun foo[A](using Foo[A])(using A)
+//│ ║  l.54: 	fun foo[A](using Foo[A])(using A)
 //│ ║        	                               ^
-//│ ╙── Expected: A; Available: (Foo[Baz])
+//│ ╙── Expected: A; Available: (Foo[Baz], Baz)
 //│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
 
 
@@ -53,12 +70,12 @@ fun foo[A](using A)(using Foo[A])
 :todo
 foo
 //│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
-//│ ║  l.54: 	foo
+//│ ║  l.71: 	foo
 //│ ║        	^^^
 //│ ╟── Required by contextual parameter declaration: 
-//│ ║  l.51: 	fun foo[A](using A)(using Foo[A])
+//│ ║  l.68: 	fun foo[A](using A)(using Foo[A])
 //│ ║        	                 ^
-//│ ╙── Expected: A; Available: (Foo[Baz])
+//│ ╙── Expected: A; Available: (Foo[Baz], Baz)
 //│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
 
 
@@ -68,25 +85,51 @@ use Foo[Bar[Baz]] = new Foo
 :e
 foo
 //│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
-//│ ║  l.69: 	foo
+//│ ║  l.86: 	foo
 //│ ║        	^^^
 //│ ╟── Required by contextual parameter declaration: 
-//│ ║  l.51: 	fun foo[A](using A)(using Foo[A])
+//│ ║  l.68: 	fun foo[A](using A)(using Foo[A])
 //│ ║        	                 ^
-//│ ╙── Expected: A; Available: (Foo[Bar[Baz]], Foo[Baz])
+//│ ╙── Expected: A; Available: (Foo[Bar[Baz]], Foo[Baz], Baz)
 //│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
 
 use Bar[Baz] = new Bar
 
-:todo
+:fixme
 foo
 //│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
-//│ ║  l.82: 	foo
+//│ ║  l.99: 	foo
 //│ ║        	^^^
 //│ ╟── Required by contextual parameter declaration: 
-//│ ║  l.51: 	fun foo[A](using A)(using Foo[A])
+//│ ║  l.68: 	fun foo[A](using A)(using Foo[A])
+//│ ║        	                 ^
+//│ ╙── Expected: A; Available: (Foo[Bar[Baz]], Foo[Baz], Baz, Bar[Baz])
+//│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
+
+use Bar[Int] = new Bar
+
+:fixme
+foo
+//│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
+//│ ║  l.112: 	foo
+//│ ║         	^^^
+//│ ╟── Required by contextual parameter declaration: 
+//│ ║  l.68: 	fun foo[A](using A)(using Foo[A])
+//│ ║        	                 ^
+//│ ╙── Expected: A; Available: (Foo[Bar[Baz]], Foo[Baz], Baz, Bar[Int], Bar[Baz])
+//│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
+
+use Bar[Baz] = new Bar
+
+:todo
+foo
+//│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
+//│ ║  l.125: 	foo
+//│ ║         	^^^
+//│ ╟── Required by contextual parameter declaration: 
+//│ ║  l.68: 	fun foo[A](using A)(using Foo[A])
 //│ ║        	                 ^
-//│ ╙── Expected: A; Available: (Foo[Bar[Baz]], Foo[Baz], Bar[Baz])
+//│ ╙── Expected: A; Available: (Foo[Bar[Baz]], Foo[Baz], Baz, Bar[Baz], Bar[Int], Bar[Baz])
 //│ /!!!\ Uncaught error: hkmc2.InternalError: Not in scope: member:foo (class hkmc2.semantics.BlockMemberSymbol)
 
 

hkmc2/shared/src/test/mlscript/ctx/ClassCtxParams.mls

@@ -0,0 +1,53 @@
+:js
+:todo
+
+
+class Foo()(using Int)
+//│ ╔══[ERROR] Multiple parameter lists are not supported for this definition.
+//│ ║  l.5: 	class Foo()(using Int)
+//│ ╙──     	      ^^^^^^^^^^^^^^^^
+
+class Foo(using val n: Int)
+//│ ╔══[ERROR] Illegal definition in term position.
+//│ ║  l.10: 	class Foo(using val n: Int)
+//│ ╙──      	                    ^^^^^^
+
+
+fun summon[A](using a: A) = a
+
+class Foo(using Int) with
+  fun foo() = summon[Int]
+//│ ╔══[ERROR] Missing instance for contextual parameter of type `A` in this call
+//│ ║  l.19: 	  fun foo() = summon[Int]
+//│ ║        	              ^^^^^^^^^^
+//│ ╟── Required by contextual parameter declaration: 
+//│ ║  l.16: 	fun summon[A](using a: A) = a
+//│ ║        	                    ^^^^
+//│ ╙── Expected: A; Available: ()
+
+
+fun summon(using a: Int) = a
+
+class Foo(using Int) with
+  fun foo() = summon
+//│ ╔══[ERROR] Missing instance for contextual parameter of type `Int` in this call
+//│ ║  l.32: 	  fun foo() = summon
+//│ ║        	              ^^^^^^
+//│ ╟── Required by contextual parameter declaration: 
+//│ ║  l.29: 	fun summon(using a: Int) = a
+//│ ║        	                 ^^^^^^
+//│ ╙── Expected: Int; Available: ()
+
+Foo()
+//│ = Foo()
+
+
+fun foo(using Int) = 1
+
+use Int = 1
+
+:re
+foo()
+//│ ═══[RUNTIME ERROR] TypeError: tmp is not a function
+
+