use[T] as Summon (#310)

Co-authored-by: Lionel Parreaux <[email protected]>

Author: FlandiaYingman

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

@@ -610,6 +610,12 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
         msg"This annotation has no effect." -> ann.toLoc ::
         msg"Such annotations are not supported on ${receiver.describe} terms." -> receiver.toLoc :: Nil))
       term(receiver)(k)
+    case use: Summon =>
+      warnStmt
+      use.sym match
+        case S(_: ErrorSymbol) => End("missing instance")
+        case S(sym) => k(subst(Value.Ref(sym)))
+        case N => lastWords(s"unresolved summon: ${use}")
     case Error => End("error")
 
     // case _ =>

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

@@ -417,6 +417,13 @@ extends Importer:
         case N =>
           raise(ErrorReport(msg"Name not found: $name" -> tree.toLoc :: Nil))
           Term.Error
+    // A use[T] construct: analogous to Scala's summon[T].
+    case TyApp(Keywrd(Keyword.`use`), targs) => 
+      if targs.length != 1 then
+        raise(ErrorReport(msg"Illegal use[T] construct. Only one type is allowed." -> tree.toLoc :: Nil))
+        Term.Error
+      val ty = term(targs.head)
+      Term.Summon(ty)(tree, N)
     case TyApp(lhs, targs) =>
       Term.TyApp(subterm(lhs, inTyAppPrefix = true), targs.map {
         case Modified(Keyword.`in`, inLoc, arg) => Term.WildcardTy(S(subterm(arg)), N)
@@ -1240,7 +1247,7 @@ extends Importer:
           param(hd, flags.ctx, inDataClass)(using ctx) match
           case S((isSpd, p)) =>
             val isCtx = hd match
-              case Modified(Keyword.`using`, _, _) => true
+              case TermDef(k = Ins, rhs = N) => true
               case _ => false
             val newCtx = ctx + (p.sym.name -> p.sym)
             val newFlags = if isCtx then flags.copy(ctx = true) else flags

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

@@ -5,19 +5,15 @@ import mlscript.utils.*, shorthands.*
 import utils.TraceLogger
 
 import syntax.Tree
-import syntax.{Fun, Ins, Mod, ImmutVal}
+import syntax.{Fun, Ins, Mod, ImmutVal, MutVal}
 import syntax.Keyword.{`if`}
 import semantics.Term
 import semantics.Elaborator.State
 import Resolver.ICtx.Type
 
 import Message.MessageContext
 import scala.annotation.tailrec
-import hkmc2.syntax.MutVal
-import hkmc2.semantics.ClassDef.Parameterized
-import hkmc2.semantics.ClassDef.Plain
-import hkmc2.syntax.Tree.Ident
-import java.sql.Ref
+import hkmc2.semantics.Resolver.ICtx.Instance
 
 object Resolver:
 
@@ -52,20 +48,35 @@ object Resolver:
     tEnv: Map[VarSymbol, Type]
   ):
 
-    def +(typ: Type.Concrete, sym: Symbol): ICtx =
+    def +(typ: Type.Specified, sym: Symbol): ICtx =
       val newLs = (typ -> ICtx.Instance(sym)) :: iEnv.getOrElse(typ.toSym, Nil)
       val newEnv = iEnv + (typ.toSym -> newLs)
       copy(iEnv = newEnv)
 
     def withTypeArg(param: VarSymbol, arg: Type): ICtx =
       copy(tEnv = tEnv + (param -> arg))
 
-    def get(query: Type.Concrete): Opt[ICtx.Instance] =
-      iEnv.getOrElse(query.toSym, Nil)
-        .find: (typ, _) => 
-          compare(query, typ)
-        .map: (_, instance) => 
-          instance
+    def get(query: Type.Specified): Ls[Message -> Opt[Loc]] \/ ICtx.Instance =
+      def resolveTpe(tpe: Type.Specified): Opt[Type.Sym] = tpe.toSym match
+        case tpe @ Type.Sym(sym: VarSymbol) => tEnv.get(sym) match
+          // Specified type variable. Resolve it recursively.
+          case S(tpe: Type.Specified) => resolveTpe(tpe)
+          // Unspecified type variable. Reject it.
+          case S(Type.Unspecified) => N
+          // Unbound type variable. Just use it.
+          case N => S(tpe)
+        case tpe => S(tpe)
+      resolveTpe(query) match
+        case S(tpe) => iEnv.getOrElse(tpe, Nil)
+          .find: (typ, _) => 
+            compare(query, typ)
+          .map: (_, instance) => 
+            instance
+          .toRight:
+            msg"Missing instance: Expected: ${describeType(query)}; Available: ${showEnv}" -> N :: Nil
+        case N => L:
+          msg"Illegal query for an unspecified type variable ${query.show}." -> N :: Nil
+        
 
     private def compare(a: Type, b: Type): Boolean = (a, b) match
       case (Type.Unspecified, _) => true
@@ -86,6 +97,12 @@ object Resolver:
         .flatMap(_.map((typ, instance) => s"${typ.show}"))
         .mkString("(", ", ", ")")
 
+    def describeType(tpe: Type): Str = tpe match
+      case Type.Sym(sym: VarSymbol) =>
+        s"${tEnv.get(sym).getOrElse(Type.Unspecified).show} (${tpe.show})"
+      case _ => 
+        s"${tpe.show}"
+    
   object ICtx:
 
     enum Type:
@@ -110,8 +127,8 @@ object Resolver:
         case Unspecified => "‹unspecified›"
 
     object Type:
-      type Concrete = Sym | App
-      extension (t: Concrete)
+      type Specified = Sym | App
+      extension (t: Specified)
         def toSym: Sym = t match
           case sym: Sym => sym
           case App(sym, _) => sym
@@ -424,6 +441,26 @@ class Resolver(tl: TraceLogger)
       case Term.Ref(_) =>
         resolveSymbol(t)
         (t.termDefn, ictx)
+          
+      case use @ Term.Summon(ty) =>
+        traverse(ty, expect = NonModule(N))
+        resolveType(ty) match
+          case S(tpe: Type.Specified) =>
+            ictx.get(tpe) match
+              case R(i) =>
+                log(s"Resolved type ${tpe} with instance ${i}")
+                use.sym = S(i.sym)
+              case L(msgs) =>
+                use.sym = S(ErrorSymbol("Missing Instance", use.tree))
+                raise(ErrorReport(
+                  msg"Cannot query instance for use-expression of type ${ictx.describeType(tpe)}" -> t.toLoc ::
+                  msgs
+                ))
+          case N =>
+            use.sym = S(ErrorSymbol("Missing Type", use.tree))
+            // There is an error during resolving the type signature.
+            // The error should have been reported.
+        (t.termDefn, ictx)
 
     log(s"Resolving resolvable with defn = ${defn}")
 
@@ -651,9 +688,9 @@ class Resolver(tl: TraceLogger)
     log(s"Resolving implicit argument, expecting a ${p.sign}")
     p.sign match
       case S(sign) => resolveType(sign) match
-        case S(tpe: Type.Concrete) =>
+        case S(tpe: Type.Specified) =>
           ictx.get(tpe) match
-            case S(i) =>
+            case R(i) =>
               log(s"Resolved ${p.sign} with instance ${i}")
               val ref = i.sym.ref()
               traverse(ref,
@@ -663,11 +700,10 @@ class Resolver(tl: TraceLogger)
                   else NonModule(S(msg"Module argument passed to a non-module parameter.")),
               )
               Fld(p.flags, ref, N)
-            case N =>
+            case L(msgs) =>
               raise(ErrorReport(
-                msg"Missing instance for contextual parameter of type `${tpe.show}` in this call" -> lhs.toLoc ::
-                msg"Required by contextual parameter declaration: " -> p.toLoc ::
-                msg"Expected: ${tpe.show}; Available: ${ictx.showEnv}" -> N :: Nil))
+                msg"Cannot query instance of type ${ictx.describeType(tpe)} for call: " -> lhs.toLoc ::
+                msg"Required by contextual parameter declaration: " -> p.toLoc :: msgs))
               Fld(FldFlags.empty, Term.Error, N)
         case N =>
           // There is an error during resolving the type signature.
@@ -690,7 +726,7 @@ class Resolver(tl: TraceLogger)
           else NonModule(S(msg"Non-module parameter must have a non-module type.")),
       )
 
-  def resolveType(t: Term): Opt[ICtx.Type.Concrete] = t match
+  def resolveType(t: Term): Opt[ICtx.Type.Specified] = t match
       // If the term is a type application, e.g., T[A, ...], resolve the
       // type constructor and arguments respectively.
       case Term.TyApp(con, args) => 

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

@@ -43,6 +43,7 @@ sealed trait ResolvableImpl:
     case t: Term.TyApp => t.copy()(t.sym).noIArgs
     case t: Term.Sel => t.copy()(t.sym).noIArgs
     case t: Term.SynthSel => t.copy()(t.sym).noIArgs
+    case t: Term.Summon => t.copy()(t.tree, t.sym).noIArgs
 
   def instantiate(using State): Term = iargsLs match
     case N => lastWords(s"missing implicit arguments for term ${t}")
@@ -114,6 +115,7 @@ enum Term extends Statement:
   case Annotated(annot: Annot, target: Term)
   case Handle(lhs: LocalSymbol, rhs: Term, args: List[Term],
     derivedClsSym: ClassSymbol, defs: Ls[HandlerTermDefinition], body: Term)
+  case Summon(ty: Term)(val tree: Tree, var sym: Opt[Symbol]) extends Term with ResolvableImpl
 
   /**
    * The prelinminary symbol for the term that is resolved during
@@ -138,6 +140,7 @@ enum Term extends Statement:
     case sel: SelProj => sel.sym
     case app: App => app.sym
     case tyApp: TyApp => tyApp.sym
+    case summon: Summon => summon.sym
     case _ => N
 
   def sel(id: Tree.Ident, sym: Opt[FieldSymbol]): Sel =
@@ -251,6 +254,7 @@ sealed trait Statement extends AutoLocated with ProductWithExtraInfo:
     case Handle(lhs, rhs, args, derivedClsSym, defs, bod) => rhs :: args ::: defs.flatMap(_.td.subTerms) ::: bod :: Nil
     case Neg(e) => e :: Nil
     case Annotated(ann, target) => ann.subTerms ::: target :: Nil
+    case Summon(ty) => ty :: Nil
 
   // private def treeOrSubterms(t: Tree, t: Term): Ls[Located] = t match
   private def treeOrSubterms(t: Tree): Ls[Located] = t match
@@ -347,6 +351,7 @@ sealed trait Statement extends AutoLocated with ProductWithExtraInfo:
     case TypeDef(sym, tparams, rhs, _, _) =>
       s"type ${sym}${tparams.mkStringOr(", ", "[", "]")} = ${rhs.fold("")(x => x.showDbg)}"
     case Missing => "missing"
+    case Summon(ty) => s"use[${ty.showDbg}]"
 
 final case class LetDecl(sym: LocalSymbol, annotations: Ls[Annot]) extends Statement
 

hkmc2/shared/src/main/scala/hkmc2/syntax/ParseRule.scala

@@ -305,7 +305,7 @@ class ParseRules(using State):
         ) { case (body, _) => Tree.Constructor(body) },
     Kw(`fun`)(termDefBody(Fun)),
     Kw(`val`)(termDefBody(ImmutVal)),
-    Kw(`use`)(termDefBody(Ins)),
+    Kw(`using`)(termDefBody(Ins)),
     typeAliasLike(`type`, Als),
     typeAliasLike(`pattern`, Pat),
     Kw(`class`)(typeDeclBody(Cls)),
@@ -333,8 +333,8 @@ class ParseRules(using State):
     modified(`return`),
     modified(`throw`),
     modified(`import`), // TODO improve – only allow strings
+    singleKw(`use`)(Keywrd(`use`)),
     // modified(`type`),
-    modified(`using`),
     singleKw(`true`)(BoolLit(true)),
     singleKw(`false`)(BoolLit(false)),
     singleKw(`undefined`)(UnitLit(false)),

hkmc2/shared/src/main/scala/hkmc2/syntax/Tree.scala

@@ -245,7 +245,7 @@ enum Tree extends AutoLocated:
     case Spread(Keyword.`...`, _, S(und: Under)) => S(S(true), new Ident("_").withLocOf(und), N)
     case InfixApp(lhs: Ident, Keyword.`:`, rhs) => S(N, lhs, S(rhs))
     case TermDef(ImmutVal, inner, _) => inner.asParam(inUsing)
-    case Modified(Keyword.`using`, _, inner) => inner match
+    case TermDef(Ins, inner, N) => inner match
       // Param of form (using name: Type). Parse it as usual.
       case inner: InfixApp => inner.asParam(inUsing)
       // Param of form (using Type). Synthesize an identifier for it.

hkmc2/shared/src/test/mlscript-compile/apps/parsing/Lexer.mls

@@ -57,7 +57,7 @@ fun makeLineLookupTable(text: Str): LineLookupTable =
   LineLookupTable(ns)
 
 fun lex(str: Str, options) =
-  use LineLookupTable = makeLineLookupTable(str)
+  using LineLookupTable = makeLineLookupTable(str)
 
   fun char(idx: Int) = if idx < str.length
     then (Some of str.charAt of idx) else None

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

@@ -11,44 +11,50 @@ module M with
 
 :e
 M.f
-//│ ╔══[ERROR] Missing instance for contextual parameter of type `Int` in this call
+//│ ╔══[ERROR] Cannot query instance of type Int for call: 
 //│ ║  l.13: 	M.f
 //│ ║        	^^^
 //│ ╟── Required by contextual parameter declaration: 
 //│ ║  l.10: 	  fun f(using Int)
 //│ ║        	              ^^^
-//│ ╙── Expected: Int; Available: ()
+//│ ╙── Missing instance: Expected: Int; Available: ()
 
 :e
-use 42 = 42
+using 42 = 42
 //│ ╔══[ERROR] Expected a type symbol, got integer literal
-//│ ║  l.23: 	use 42 = 42
-//│ ╙──      	    ^^
+//│ ║  l.23: 	using 42 = 42
+//│ ╙──      	      ^^
 
 val someInt = 42
 
 :e
-use someInt = 42
+using someInt = 42
 //│ ╔══[ERROR] Expected a type, got reference
-//│ ║  l.31: 	use someInt = 42
-//│ ╙──      	    ^^^^^^^
+//│ ║  l.31: 	using someInt = 42
+//│ ╙──      	      ^^^^^^^
+
+:e
+using someInt: Int = 42
+//│ ╔══[ERROR] Expected a type symbol, got block
+//│ ║  l.37: 	using someInt: Int = 42
+//│ ╙──      	      ^^^^^^^^^^^^
 
 module M with
   fun bar[A, B](a: A, b: B) = a + b
 
 :e
 M.bar[](1, 2)
 //│ ╔══[ERROR] Expected 2 type arguments, got 0
-//│ ║  l.40: 	M.bar[](1, 2)
+//│ ║  l.46: 	M.bar[](1, 2)
 //│ ╙──      	^^^^^
 
 :e
 M.bar[Int](1, 2)
 //│ ╔══[ERROR] Expected 2 type arguments, got 1
-//│ ║  l.46: 	M.bar[Int](1, 2)
+//│ ║  l.52: 	M.bar[Int](1, 2)
 //│ ╙──      	^^^^^^^^^
 
-use Int = 42
+using Int = 42
 
 module M with
   fun foo()(using a: Int)
@@ -57,3 +63,19 @@ module M with
 :todo
 :e
 M.foo()
+
+:e
+fun f[T](using t: T) = t
+f
+//│ ╔══[ERROR] Cannot query instance of type ‹unspecified› (T) for call: 
+//│ ║  l.69: 	f
+//│ ║        	^
+//│ ╟── Required by contextual parameter declaration: 
+//│ ║  l.68: 	fun f[T](using t: T) = t
+//│ ║        	               ^^^^
+//│ ╙── Illegal query for an unspecified type variable T.
+
+:fixme // graceful error
+:e
+fun f(using t: Int = 42) = t
+//│ /!!!\ Uncaught error: scala.MatchError: TermDef(Ins,InfixApp(Ident(t),keyword ':',Ident(Int)),Some(IntLit(42))) (of class hkmc2.syntax.Tree$TermDef)