Add code generation for bbml

hkmc2/shared/src/main/scala/hkmc2/bbml/bbML.scala

@@ -482,13 +482,8 @@ class BBTyper(using elState: Elaborator.State, tl: TL):
               case _ => (error(msg"${field.name} is not a valid member in class ${clsSym.nme}" -> t.toLoc :: Nil), Bot)
           case N => 
             (error(msg"Not a valid class: ${cls.describe}" -> cls.toLoc :: Nil), Bot)
-      case Term.App(lhs @ Term.SynthSel(_, Ident(nme)), Term.Tup(Nil)) if ctx.ctx.get(nme).map(e => e match {
-        case _: Elaborator.Ctx.GetElem => true
-        case _ => false
-      }).getOrElse(lhs.sym.map(_.defn match {
-        case S(TermDefinition(_, Fun, _, Nil, _, S(_), _, _)) => true
-        case _ => false
-      }).getOrElse(false)) => typeCheck(lhs) // * Gettters
+      case Term.App(lhs: Term.SynthSel, Term.Tup(Nil)) if lhs.sym.map(_.isGetter).getOrElse(false) =>
+        typeCheck(lhs) // * Getter access will be elaborated to applications. But they cannot be typed as normal applications.
       case t @ Term.App(lhs, Term.Tup(rhs)) =>
         val (funTy, lhsEff) = typeCheck(lhs)
         app((funTy, lhsEff), rhs, t)

hkmc2/shared/src/main/scala/hkmc2/codegen/js/JSBuilder.scala

@@ -183,6 +183,10 @@ class JSBuilder(using Elaborator.State, Elaborator.Ctx) extends CodeBuilder:
                     doc" # ${td.sym.nme}($params) { #{  # ${
                       bodyDoc
                     } #}  # }"
+                  case td @ FunDefn(_, Nil, bod) =>
+                    doc" # ${td.sym.nme}() { #{  # ${
+                      this.body(bod)
+                    } #}  # }"
                 .mkDocument(" ")
               }${
                 if mtds.exists(_.sym.nme == "toString")

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

@@ -158,7 +158,7 @@ extends Importer:
   def mkLetBinding(sym: LocalSymbol, rhs: Term): Ls[Statement] =
     LetDecl(sym) :: DefineVar(sym, rhs) :: Nil
 
-  def resolveField(srcTree: Tree, base: Opt[Symbol], nme: Ident): Opt[FieldSymbol] =
+  def resolveField(srcTree: Tree, base: Opt[Symbol], nme: Ident)(using Ctx): Opt[FieldSymbol] =
     base match
     case S(psym: BlockMemberSymbol) =>
       psym.modTree match
@@ -170,6 +170,9 @@ extends Importer:
           N
       case N =>
         N
+    case S(_: TopLevelSymbol) => ctx.get(nme.name).flatMap(_.symbol) match
+      case S(sym: FieldSymbol) => S(sym)
+      case _ => N
     case _ => N
 
   def cls(tree: Tree, inAppPrefix: Bool): Ctxl[Term] = trace[Term](s"Elab class ${tree.showDbg}", r => s"~> $r"):
@@ -355,12 +358,7 @@ extends Importer:
       val res = if inAppPrefix
       then Term.SynthSel(preTrm, nme)(sym)
       else Term.Sel(preTrm, nme)(sym)
-      val isGetter = ctx.get(nme.name) match // TODO: create a function for this logic
-        case S(_: Ctx.GetElem) => true
-        case _ => sym.flatMap(_.defn) match
-          case S(TermDefinition(_, Fun, _, Nil, _, S(_), _, _)) => true
-          case _ => false
-      if isGetter then
+      if sym.map(_.isGetter).getOrElse(false) then
         val emptyTup: Tree.Tup = Tree.Tup(Nil)
         Term.App(res, Term.Tup(Nil)(emptyTup))(Tree.App(t, emptyTup), FlowSymbol("‹get-res›"))
       else res

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

@@ -122,6 +122,9 @@ end BlockMemberSymbol
 sealed abstract class MemberSymbol[Defn <: Definition](using State) extends Symbol:
   def nme: Str
   var defn: Opt[Defn] = N
+  lazy val isGetter: Bool = defn match
+    case S(TermDefinition(_, Fun, _, Nil, _, S(_), _, _)) => true
+    case _ => false
 
 
 class TermSymbol(val k: TermDefKind, val owner: Opt[InnerSymbol], val id: Tree.Ident)(using State)

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

@@ -21,6 +21,42 @@ globalThis.t
 //│ = 42
 
 
+this.t
+//│ = 42
+
+
+:sjs
+module M with
+  fun t = 0
+//│ JS:
+//│ const M$class = class M {
+//│   constructor() {
+//│     
+//│   }
+//│   t() {
+//│     return 0;
+//│   }
+//│   toString() { return "M"; }
+//│ };
+//│ this.M = new M$class;
+//│ this.M.class = M$class;
+//│ undefined
+
+
+:sjs
+M.t
+//│ JS:
+//│ let selRes, tmp;
+//│ selRes = this.M.t;
+//│ if (selRes === undefined) {
+//│   throw new this.Error("Access to required field 't' yielded 'undefined'");
+//│ } else {
+//│   tmp = selRes;
+//│ }
+//│ tmp() ?? null
+//│ = 0
+
+
 :sjs
 fun test() =
   fun whoops = 42