Merge branch 'hkmc2' into hkmc2

Author: FlandiaYingman

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

@@ -72,7 +72,7 @@ extends Importer:
       term(Block(LetLike(`let`, lhs, rhso, N) :: bod :: Nil))
     case LetLike(`let`, lhs, S(rhs), N) =>
       raise(ErrorReport(
-        msg"Expected a right-hand side for let bindings in expression position" ->
+        msg"Expected a body for let bindings in expression position" ->
           tree.toLoc :: Nil))
       block(LetLike(`let`, lhs, S(rhs), N) :: Nil)._1
     case LetLike(`set`, lhs, S(rhs), N) =>
@@ -89,6 +89,23 @@ extends Importer:
           term(bod),
         ), Term.Assgn(lt, sym.ref(id))))
       case _ => ??? // TODO error
+    case Handle(id, cls, blk, S(bod)) =>
+      term(Block(Handle(id, cls, blk, N) :: bod :: Nil))
+    case Handle(id: Ident, cls: Ident, Block(sts), N) =>
+      raise(ErrorReport(
+        msg"Expected a body for handle bindings in expression position" ->
+          tree.toLoc :: Nil))
+          
+      val sym =
+        fieldOrVarSym(Handler, id)
+      val newCtx = ctx.copy(locals = ctx.locals + (id.name -> sym))
+      Term.Handle(sym, term(cls)(using newCtx), ObjBody(block(sts)._1))
+      
+    case h: Handle =>
+      raise(ErrorReport(
+        msg"Unsupported handle binding shape" ->
+          h.toLoc :: Nil))
+      Term.Error
     case id @ Ident("this") =>
       ctx.getOuter match
       case S(sym) =>
@@ -425,6 +442,17 @@ extends Importer:
       case (tree @ LetLike(`let`, lhs, S(rhs), N)) :: sts =>
         raise(ErrorReport(msg"Unsupported let binding shape" -> tree.toLoc :: Nil))
         go(sts, Term.Error :: acc)
+      case (hd @ Handle(id: Ident, cls: Ident, Block(sts_), N)) :: sts =>
+        val sym =
+          fieldOrVarSym(LetBind, id)
+        log(s"Processing `handle` statement $id (${sym}) ${ctx.outer}")
+        val newAcc = Term.Handle(sym, term(cls), ObjBody(block(sts_)._1)) :: acc
+        ctx.copy(locals = ctx.locals + (id.name -> sym)) givenIn:
+          go(sts, newAcc)
+      case (tree @ Handle(_, _, _, N)) :: sts =>
+        raise(ErrorReport(msg"Unsupported handle binding shape" -> tree.toLoc :: Nil))
+        go(sts, Term.Error :: acc)
+
       case Def(lhs, rhs) :: sts =>
         lhs match
         case id: Ident =>

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

@@ -35,6 +35,7 @@ enum Term extends Statement:
   case Deref(ref: Term)
   case Ret(result: Term)
   case Try(body: Term, finallyDo: Term)
+  case Handle(lhs: LocalSymbol, rhs: Term, defs: ObjBody)
 
   var symbol: Opt[Symbol] = N
 
@@ -122,6 +123,7 @@ sealed trait Statement extends AutoLocated:
       td.rhs.toList
     case Import(sym, pth) => Nil
     case Try(body, finallyDo) => body :: finallyDo :: Nil
+    case Handle(lhs, rhs, defs) => rhs :: defs._1 :: Nil
     case This(_) => Nil
     case Neg(e) => e :: Nil
 
@@ -171,6 +173,7 @@ sealed trait Statement extends AutoLocated:
     case Asc(term, ty) => s"${term.toString}: ${ty.toString}"
     case LetDecl(sym) => s"let ${sym}"
     case DefineVar(sym, rhs) => s"${sym} = ${rhs.showDbg}"
+    case Handle(lhs, rhs, defs) => s"handle ${lhs} = ${rhs} ${defs}"
     case Region(name, body) => s"region ${name.nme} in ${body.showDbg}"
     case RegRef(reg, value) => s"(${reg.showDbg}).ref ${value.showDbg}"
     case Assgn(lhs, rhs) => s"${lhs.showDbg} := ${rhs.showDbg}"

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

@@ -72,6 +72,7 @@ object Keyword:
   val `is` = Keyword("is", nextPrec, curPrec, canStartInfixOnNewLine = false)
   val `as` = Keyword("as", nextPrec, curPrec)
   val `let` = Keyword("let", nextPrec, curPrec)
+  val `handle` = Keyword("handle", nextPrec, curPrec)
   val `region` = Keyword("region", curPrec, curPrec)
   val `rec` = Keyword("rec", N, N)
   val `in` = Keyword("in", curPrec, curPrec)

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

@@ -65,16 +65,17 @@ object ParseRule:
     Expr(body)(k) ::
     Blk(body)(k) ::
     Nil
-  
-  val typeDeclTemplate: Alt[Opt[Tree]] =
+
+  def typeDeclTemplateThen[A](after: Alt[A]*): Alt[(S[Tree], A)] =
     Kw(`with`):
       ParseRule("type declaration body")(
         Blk(
-          ParseRule("type declaration block"):
-            End(())
-        ) { case (res, ()) => S(res) }
+          ParseRule("type declaration block")(after*)
+        ) { case (res, t) => (S(res), t) }
       )
 
+  val typeDeclTemplate: Alt[Opt[Tree]] = typeDeclTemplateThen(End(())).map((res, _) => res)
+  
   /*
   def termDefBody(k: TermDefKind): ParseRule[Tree] = 
       ParseRule(s"'${k.str}' binding keyword")(
@@ -138,8 +139,8 @@ object ParseRule:
                   ParseRule(s"'${kw.name}' binding right-hand side")(
                     Kw(`in`):
                       ParseRule(s"'${kw.name}' binding `in` clause")(
-                        exprOrBlk(ParseRule(s"'${kw.name}' binding body")(End(())))((body, _: Unit) => S(body))
-                    *),
+                        exprOrBlk(ParseRule(s"'${kw.name}' binding body")(End(())))((body, _: Unit) => S(body))*
+                      ),
                     End(N)
                   )
                 ) { (rhs, body) => (S(rhs), body) }*
@@ -189,6 +190,25 @@ object ParseRule:
   val prefixRules: ParseRule[Tree] = ParseRule("start of statement", omitAltsStr = true)(
     letLike(`let`),
     letLike(`set`),
+    
+    Kw(`handle`):
+      ParseRule("'handle' binding keyword"):
+        Expr(
+          ParseRule("'handle' binding head"):
+            Kw(`=`):
+              ParseRule("'handle' binding equals sign"):
+                Expr(
+                  ParseRule("'handle' binding class name"):
+                    typeDeclTemplateThen(
+                      Kw(`in`):
+                        ParseRule(s"'handle' binding `in` clause")(
+                          exprOrBlk(ParseRule(s"'handle' binding body")(End(())))((body, _: Unit) => S(body))*
+                        ),
+                      End(None)
+                    )
+                ) { case (rhs, (S(defs), body)) => (rhs, defs, body) }
+        ) { case (lhs, (rhs, defs, body))=> Handle(lhs, rhs, defs, body) }
+    ,
     Kw(`new`):
       ParseRule("`new` keyword"):
         Expr(ParseRule("`new` expression")(End(())))((body, _: Unit) => New(body))

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

@@ -49,6 +49,7 @@ enum Tree extends AutoLocated:
   case Block(stmts: Ls[Tree])
   case OpBlock(items: Ls[Tree -> Tree])
   case LetLike(kw: Keyword.letLike, lhs: Tree, rhs: Opt[Tree], body: Opt[Tree])
+  case Handle(lhs: Tree, cls: Tree, defs: Tree, body: Opt[Tree])
   case Def(lhs: Tree, rhs: Tree)
   case TermDef(k: TermDefKind, head: Tree, rhs: Opt[Tree]) extends Tree with TermDefImpl
   case TypeDef(k: TypeDefKind, head: Tree, extension: Opt[Tree], body: Opt[Tree]) extends Tree with TypeDefImpl
@@ -77,6 +78,9 @@ enum Tree extends AutoLocated:
     case OpBlock(items) => items.flatMap:
       case (op, body) => op :: body :: Nil
     case LetLike(kw, lhs, rhs, body) => lhs :: Nil ++ rhs ++ body
+    case Handle(lhs, rhs, defs, body) => body match
+      case Some(value) => lhs :: rhs :: defs :: value :: Nil
+      case None => lhs :: rhs :: defs :: Nil
     case TypeDef(k, head, extension, body) =>
       head :: extension.toList ::: body.toList
     case Modified(_, _, body) => Ls(body)
@@ -129,6 +133,7 @@ enum Tree extends AutoLocated:
     case Region(name, body) => "region"
     case RegRef(reg, value) => "region reference"
     case Effectful(eff, body) => "effectful"
+    case Handle(_, _, _, _) => "handle"
 
   def showDbg: Str = toString // TODO
 
@@ -171,6 +176,7 @@ sealed abstract class Val(str: Str, desc: Str) extends ValLike(str, desc)
 case object ImmutVal extends Val("val", "value")
 case object MutVal extends Val("mut val", "mutable value")
 case object LetBind extends ValLike("let", "let binding")
+case object Handler extends TermDefKind("handler", "handler binding")
 case object ParamBind extends ValLike("", "parameter")
 case object Fun extends TermDefKind("fun", "function")
 sealed abstract class TypeDefKind(desc: Str) extends DeclKind(desc)

hkmc2/shared/src/test/mlscript/codegen/Bindings.mls

@@ -73,14 +73,14 @@ let x += 1 = 0 in x
 
 :e
 (let x = 1) + 1
-//│ ╔══[ERROR] Expected a right-hand side for let bindings in expression position
+//│ ╔══[ERROR] Expected a body for let bindings in expression position
 //│ ║  l.75: 	(let x = 1) + 1
 //│ ╙──      	     ^^^^^
 //│ = NaN
 
 :e
 (let f(x) = x) + 1
-//│ ╔══[ERROR] Expected a right-hand side for let bindings in expression position
+//│ ╔══[ERROR] Expected a body for let bindings in expression position
 //│ ║  l.82: 	(let f(x) = x) + 1
 //│ ╙──      	     ^^^^^^^^
 //│ = NaN

hkmc2/shared/src/test/mlscript/parser/Handler.mls

@@ -0,0 +1,69 @@
+
+:pe
+handle
+//│ ╔══[PARSE ERROR] Expected expression after 'handle' binding keyword; found end of input instead
+//│ ║  l.3: 	handle
+//│ ╙──     	      ^
+
+:pe
+handle h
+//│ ╔══[PARSE ERROR] Expected '=' keyword after 'handle' binding head; found end of input instead
+//│ ║  l.9: 	handle h
+//│ ╙──     	        ^
+
+:pe
+handle h = Eff
+//│ ╔══[PARSE ERROR] Expected 'with' keyword after 'handle' binding class name; found end of input instead
+//│ ║  l.15: 	handle h = Eff
+//│ ╙──      	              ^
+
+:parseOnly
+handle h = Eff with
+  fun f(r) = r(0)
+  fun g(a, r) = r(1)
+//│ Parsed:
+//│ 	Handle(Ident(h),Ident(Eff),Block(List(TermDef(Fun,App(Ident(f),Tup(List(Ident(r)))),Some(App(Ident(r),Tup(List(IntLit(0)))))), TermDef(Fun,App(Ident(g),Tup(List(Ident(a), Ident(r)))),Some(App(Ident(r),Tup(List(IntLit(1)))))))),None)
+
+
+:e
+fun foo(x) = 1
+handle 1 = 1 with
+  fun f(r) = r(0)
+in
+  foo(h)
+//│ ╔══[ERROR] Unsupported handle binding shape
+//│ ║  l.30: 	handle 1 = 1 with
+//│ ║        	       ^^^^^^^^^^
+//│ ║  l.31: 	  fun f(r) = r(0)
+//│ ╙──      	^^^^^^^^^^^^^^^^^
+//│ ╔══[ERROR] Name not found: h
+//│ ║  l.33: 	  foo(h)
+//│ ╙──      	      ^
+
+class Eff
+fun foo(h) = 0
+handle h = Eff with
+  fun f(r) = r(0)
+in
+  foo(h)
+
+class Eff
+fun foo(h) = 0
+handle h = Eff with
+  fun f(r) = r(0)
+  fun g(a, r) = r(1)
+foo(h)
+
+:e
+(
+  handle h = Eff with
+    fun f(r) = r(0)
+    fun g(a, r) = r(1)
+) + 1
+//│ ╔══[ERROR] Expected a body for handle bindings in expression position
+//│ ║  l.59: 	  handle h = Eff with
+//│ ║        	         ^^^^^^^^^^^^
+//│ ║  l.60: 	    fun f(r) = r(0)
+//│ ║        	^^^^^^^^^^^^^^^^^^^
+//│ ║  l.61: 	    fun g(a, r) = r(1)
+//│ ╙──      	^^^^^^^^^^^^^^^^^^^^^^