Instrumentation (without Call)

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

@@ -20,7 +20,7 @@ import semantics.Term.{Throw => _, *}
 import semantics.Elaborator.{State, Ctx, ctx}
 
 import syntax.{Literal, Tree}
-import hkmc2.syntax.Fun
+import hkmc2.syntax.{Fun, Keyword}
 
 
 abstract class TailOp extends (Result => Block)
@@ -251,14 +251,20 @@ class Lowering()(using Config, TL, Raise, State, Ctx):
             mod.classCompanion match
             case S(comp) => comp.defn.getOrElse(wat("Module companion without definition", mod.companion))
             case N =>
-              ClassDef.Plain(mod.owner, syntax.Cls, new ClassSymbol(Tree.DummyTypeDef(syntax.Cls), mod.sym.id),
+              val clsSymb = new ClassSymbol(Tree.DummyTypeDef(syntax.Cls), mod.sym.id)
+              val stagedAnnots = mod.annotations.collect { 
+                case Annot.Modifier(Keyword.`staged`) => Annot.Modifier(Keyword.`staged`) 
+              }
+              val newDefn = ClassDef.Plain(mod.owner, syntax.Cls, clsSymb,
                 mod.bsym,
                 Nil,
                 N,
                 ObjBody(Blk(Nil, UnitVal())),
                 S(mod.sym),
-                Nil,
+                stagedAnnots
               )
+              clsSymb.defn = S(newDefn)
+              newDefn
           case _ => _defn
         reportAnnotations(defn, defn.extraAnnotations)
         val bufferableAnnots = defn.annotations.flatMap:

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

@@ -100,8 +100,9 @@ object Printer:
     case Select(qual, name) =>
       val docQual = mkDocument(qual)
       doc"${docQual}.${name.name}"
+    case DynSelect(qual, fld, ai) =>
+      doc"${mkDocument(qual)}.(${mkDocument(fld)})"
     case x: Value => mkDocument(x)
-    case _ => TODO(path)
 
   def mkDocument(result: Result)(using Raise, Scope): Document = result match
     case Call(fun, args) => doc"${mkDocument(fun)}(${args.map(mkDocument).mkDocument(", ")})"

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

@@ -250,7 +250,8 @@ object Elaborator:
     val prettyPrintSymbol = TempSymbol(N, "prettyPrint")
     val termSymbol = TempSymbol(N, "Term")
     val blockSymbol = TempSymbol(N, "Block")
-    val shapeSymbol = TempSymbol(N, "Shape")
+    val shapeSetSymbol = TempSymbol(N, "shapeSet")
+    val optionSymbol = TempSymbol(N, "option")
     val wasmSymbol = TempSymbol(N, "wasm")
     val effectSigSymbol = ClassSymbol(DummyTypeDef(syntax.Cls), Ident("EffectSig"))
     val nonLocalRetHandlerTrm =

hkmc2/shared/src/test/mlscript-compile/Block.mls

@@ -0,0 +1,176 @@
+import "./Predef.mls"
+import "./Option.mls"
+import "./StrOps.mls"
+
+open Predef
+open StrOps
+open Option
+
+module Block with...
+
+type Opt[A] = Option[A]
+
+// dependancies referenced in Block classes, referencing implementation in Term.mls
+
+type Literal = null | undefined | Str | Int | Num | Bool
+
+type ParamList = Array[Symbol]
+
+class Symbol(val name: Str)
+type Ident = Symbol
+// this is so that we're able to retrieve information about the class from the symbol
+class ClassSymbol(val name: Str, val paramsOpt: Opt[ParamList]) extends Symbol(name)
+
+class Arg(val spread: Opt[Bool], val value: Path) 
+
+class Case with
+  constructor
+    Lit(val lit: Literal)
+    Cls(val cls: Symbol, val path: Path)
+    Tup(val len: Int, val inf: Bool)
+
+class Result with 
+  constructor
+    Call(val _fun: Path, val args: Array[Arg])
+    Instantiate(val cls: Path, val args: Array[Arg]) // assume immutable
+    Tuple(val elems: Array[Arg]) // assume immutable
+
+class Path extends Result with
+  constructor
+    Select(val qual: Path, val name: Ident)
+    DynSelect(val qual: Path, val fld: Path, val arrayIdx: Bool) // is arrayIdx used?
+    ValueRef(val l: Symbol)
+    ValueLit(val lit: Literal)
+
+class Defn with 
+  constructor 
+    ValDefn(val sym: Symbol, val rhs: Path)
+    ClsLikeDefn(val sym: ClassSymbol, val companion: Opt[ClsLikeBody]) // companion unused
+    FunDefn(val sym: Symbol, val params: Array[ParamList], val body: Block, val stage: Bool)
+
+class ClsLikeBody(val isym: Symbol, val methods: Array[FunDefn], val publicFields: Array[[Symbol, Symbol]]) // unused
+
+class Block with
+  constructor
+    Match(val scrut: Path, val arms: Array[[Case, Block]], val dflt: Opt[Block], val rest: Block)
+    Return(val res: Result, val implct: Bool)
+    Assign(val lhs: Symbol, val rhs: Result, val rest: Block)
+    Define(val defn: Defn, val rest: Block)
+    End()
+
+fun concat(b1: Block, b2: Block) = if b1 is
+  Match(scrut, arms, dflt, rest) then Match(scrut, arms, dflt, concat(rest, b2))
+  Return(res, implct) then b2 // discard return?
+  Assign(lhs, rhs, rest) then Assign(lhs, rhs, concat(rest, b2))
+  Define(defn, rest) then Define(defn, concat(rest, b2))
+  End() then b2
+
+fun showBool(b: Bool) = if b then "true" else "false"
+
+fun showLiteral(l: Literal) =
+  if l is 
+    undefined then "undefined"
+    null then "null"
+    String then "\"" + l.toString() + "\""
+    else l.toString()
+
+fun showSymbol(s: Symbol) =
+  // console.log("printing " + s)
+  if s is
+    ClassSymbol(name, args) then 
+      "ClassSymbol(" + "\"" + name + "\"" +
+      if args
+          is Some(args) then ":[" + args.map(showSymbol).join(", ") + "]"
+          is None then ""
+      + ")"
+    _ then "Symbol(" + "\"" + s.name + "\"" + ")"
+
+fun showIdent(i: Ident) = showSymbol(i)
+
+fun showPath(p: Path): Str =
+  if p is
+    Select(qual, name) then
+      "Select(" + showPath(qual) + ", " + showIdent(name) + ")"
+    DynSelect(qual, fld, arrayIdx) then
+      "DynSelect(" + showPath(qual) + ", " + showPath(fld) + ", " + showBool(arrayIdx) + ")"
+    ValueRef(l) then
+      "Ref(" + showSymbol(l) + ")"
+    ValueLit(lit) then
+      "Lit(" + showLiteral(lit) + ")"
+
+fun showArg(arg: Arg) =
+  if arg.spread is
+    Some(true) then "..."
+    Some(false) then ".."
+    else ""
+  + showPath(arg.value)
+
+fun showArgs(args: Array[Arg]) =
+  "[" + args.map(showArg).join(", ") + "]"
+
+// Case (match arm patterns)
+fun showCase(c: Case): Str =
+  if c is
+    Lit(lit) then "Lit(" + showLiteral(lit) + ")"
+    Cls(cls, path) then "Cls(" + showSymbol(cls) + ", " + showPath(path) + ")"
+    Tup(len, inf) then "Tup(" + len + ", " + inf + ")"
+
+fun showResult(r: Result): Str =
+  if r is
+    Path then showPath(r)
+    Call(f, args) then "Call(" + showPath(f) + ", " + showArgs(args) + ")"
+    Instantiate(cls, args) then "Instantiate(" + showPath(cls) + ", " + showArgs(args) + ")"
+    Tuple(elems) then "Tuple(" + showArgs(elems) + ")"
+
+fun showParamList(ps: ParamList) =
+  "[" + ps.map(s => showSymbol(s)).join(", ") + "]"
+
+fun showDefn(d: Defn): Str =
+  if d is
+    ValDefn(sym, rhs) then
+      "ValDefn(" + showSymbol(sym) + ", " + showPath(rhs) + ")"
+    FunDefn(sym, params, body, stage) then
+      "FunDefn(" + showSymbol(sym) + ", " +
+      "(" + params.map(showParamList) + "), " +
+      showBlock(body) + ", "
+      + stage + ")"
+    ClsLikeDefn(sym, companion) then
+      // TODO: print rest of the arguments
+      "ClsLikeDefn(" + showSymbol(sym) + ", " + "TODO" + ")"
+
+fun showOptBlock(ob: Opt[Block]) =
+  if ob is Some(b) then showBlock(b) else "None"
+
+fun showArm(pair: Case -> Block) =
+  if pair is [cse, body] then showCase(cse) + " -> " + showBlock(body) else "<bad-arm>"
+
+fun showBlock(b: Block): Str =
+  if b is
+    Match(scrut, arms, dflt, rest) then
+      "Match(" +
+        showPath(scrut) + ", " +
+        "[" + arms.map(showArm).join(", ") + "], " +
+        showOptBlock(dflt) + ", " +
+        showBlock(rest) + ")"
+    Return(res, implct) then 
+      "Return(" + showResult(res) + ", " + showBool(implct) + ")"
+    Assign(lhs, rhs, rest) then 
+      "Assign(" + showSymbol(lhs) + ", " + showResult(rhs) + ", " + showBlock(rest) + ")"
+    Define(defn, rest) then 
+      "Define(" + showDefn(defn) + ", " + showBlock(rest) + ")"
+    End() then "End"
+
+fun show(x) =
+  if x is
+    Symbol then showSymbol(x)
+    Path then showPath(x)
+    Result then showResult(x)
+    Case then showCase(x)
+    Defn then showDefn(x)
+    Block then showBlock(x)
+  else
+    "<unknown>"
+
+fun printCode(x) = print(show(x))
+
+fun compile(p: Block) = ???

hkmc2/shared/src/test/mlscript-compile/Shape.mls

@@ -0,0 +1,122 @@
+import "./Block.mls"
+import "./Option.mls"
+
+open Block { Literal, Symbol, ClassSymbol, showSymbol }
+open Option
+
+type Shape = Shape.Shape
+
+fun isPrimitiveType(sym: Symbol) = 
+  if sym.name is
+    "Str" then true
+    "Int" then true
+    "Num" then true
+    "Bool" then true
+    else false
+
+fun isPrimitiveTypeOf(sym: Symbol, l: Literal) =
+  if [sym.name, l] is
+    ["Str", l] and l is Str then true
+    ["Int", i] and i is Int then true
+    ["Num", n] and n is Num then true
+    ["Bool", b] and b is Bool then true
+    else false
+
+module Shape with...
+
+class Shape with
+  constructor
+    Dyn()
+    Lit(val l: Literal)
+    Arr(val shapes: Array[Shape], val inf: Bool)
+    Class(val sym: ClassSymbol, val params: Array[Shape])
+
+// FIXME: hack to check equality of classes if they have the same paramters
+fun equals(a: Shape, b: Shape) = show(a) == show(b)
+
+fun show(s: Shape) =
+  if s is
+    Dyn then "Dyn"
+    Lit(lit) then "Lit(" + Block.showLiteral(lit) + ")"
+    Arr(shapes, inf) then "Arr([" + shapes.map(show).join(", ") + "], " + inf + ")"
+    Class(sym, params) then "Class(" + showSymbol(sym) + ", [" + params.map(show).join(", ") + "])"
+
+fun zipMrg[A](a: Array[A], b: Array[A]): Array[A] =
+  a.map((a, i, _) => mrg2(a, b.at(i)))
+
+fun mrg2(s1: Shape, s2: Shape) =
+  if equals(s1, s2) then s1
+  else if [s1, s2] is 
+    [Lit(l), Class(sym, params)]
+      and isPrimitiveTypeOf(sym, l)
+      then Class(sym, params)
+    [Class(sym1, ps), Class(sym2, s2)]
+      and sym1.name == sym2.name
+      then Class(sym1, ps.map(p => [p.0, zipMrg(p.1, s2)]))
+    [Arr(s1, false), Arr(s2, false)]
+      and s1.length == s2.length
+      then Arr(zipMrg(s1, s2), false)
+    else Dyn()
+
+fun mrg(s1: Array[Shape]) = 
+  s1.reduceRight((acc, s, _, _) => mrg2(s, acc))
+
+fun sel(s1: Shape, s2: Shape): Array[Shape] = 
+  if [s1, s2] is
+    [Class(sym, params), Lit(n)] and n is Str
+      and sym.args is Some(args)
+      and args.find(_ == n)
+        == () then []
+        is i then [params.(i)]
+    [Dyn, Lit(n)] and n is Str
+      then [Dyn()]
+    [Arr(shapes, false), Lit(n)] and n is Int
+      then [shapes.(n)]
+    [Arr(shapes, false), Dyn] then
+      shapes
+    [Arr(shapes, true), _] then [Dyn()] // TODO
+    [Dyn, Lit(n)] and n is Int
+      then [Dyn()]
+    [Dyn, Dyn]
+      then [Dyn()]
+    else [] // TODO: return no possibility instead of err?
+
+fun static(s: Shape) = 
+  if s is
+    Dyn then false
+    Lit(l) then not (l is Str and isPrimitiveType(l)) // redundant bracket?
+    Class(_, params) then params.every(static)
+    Arr(shapes, false) then shapes.every(static)
+    Arr(shapes, true) then false // TODO
+
+open Block { Case }
+
+fun silh(p: Case): Shape = if p is
+  Block.Lit(l) then Lit(l)
+  Block.Cls(sym, path) then
+    val size = if sym.args is Some(i) then i else 0
+    Class(sym, Array(size).fill(Dyn))
+  Block.Tup(n, inf) then Arr(Array(n).fill(Dyn), inf)
+
+// TODO: use Option instead, since all of them return at most one shape
+fun filter(s: Shape, p: Case): Array[Shape] =
+  if [s, p] is
+    [Lit(l1), Block.Lit(l2)] and l1 == l2 then [s]
+    [Lit(l), Block.Cls(c, _)] and isPrimitiveTypeOf(c, l) then [s]
+    [Arr(ls, false), Block.Tup(n, false)] and ls.length == n then [s]
+    [Arr(ls, true), _] then [s] // TODO
+    [_, Block.Tup(ls, true)] then [s] // TODO
+    [Class(c1, _), Block.Cls(c2, _)] and c1.name == c2.name then [s]
+    [Dyn, _] then [silh(p)]
+    else []
+
+fun rest(s: Shape, p: Case): Array[Shape] =
+  if [s, p] is
+    [Lit(l1), Block.Lit(l2)] and l1 == l2 then []
+    [Lit(l), Block.Cls(c, _)] and isPrimitiveTypeOf(c, l) then []
+    [Arr(ls, false), Block.Tup(n, false)] and ls.length == n then []
+    [Arr(ls, true), _] then [s] // TODO
+    [_, Block.Tup(ls, true)] then [s] // TODO
+    [Class(c1, _), Block.Cls(c2, _)] and c1.name == c2.name then []
+    [Dyn, _] then [s]
+    else [s]

hkmc2/shared/src/test/mlscript-compile/ShapeMap.mls

@@ -0,0 +1,19 @@
+import "./Option.mls"
+import "./ShapeSet.mls"
+
+open Option { Some, None }
+open ShapeSet
+
+type ShapeMap = ShapeMap.ShapeMap
+
+module ShapeMap with...
+
+fun hash(s: ShapeSet) = s.keys().join(", ")
+
+class ShapeMap(val underlying: Map) with
+  fun add(s: ShapeSet, code) = underlying.set(hash(s), code)
+
+  fun get(s: ShapeSet) =
+    if underlying.get(hash(s))
+      == () then None
+      is value then Some of value