Llir improvement

compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala

@@ -161,7 +161,7 @@ case class CompilationUnit(includes: Ls[Str], decls: Ls[Decl], defs: Ls[Def]):
       "HiddenTheseEntities", "True", "False", "Callable", "List", "Cons", "Nil", "Option", "Some", "None", "Pair", "Tuple2", "Tuple3", "Nat", "S", "O"
     )
     stack_list(defs.filterNot { 
-      case Def.StructDef(name, _, _, _) => hiddenNames.contains(name.stripPrefix("_mls_"))
+      case d: Def.StructDef => hiddenNames.contains(d.name.stripPrefix("_mls_"))
       case _ => false
     }.map(_.toDocument))
 

compiler/shared/main/scala/mlscript/compiler/codegen/CppCompilerHost.scala

@@ -41,4 +41,4 @@ final class CppCompilerHost(val auxPath: Str):
       return
 
     output("Execution succeeded: ")
-    for line <- stdout do output(line)
+    for line <- stdout do output(line)

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

@@ -120,27 +120,24 @@ sealed abstract class Block extends Product with AutoLocated:
       (bod.freeVars - lhs) ++ rst.freeVars ++ hdr.flatMap(_.freeVars)
     case End(msg) => Set.empty
 
-  // TODO: freeVarsLLIR skips `fun` and `cls` in `Call` and `Instantiate` respectively, which is needed in some
-  // other places. However, adding them breaks some LLIR tests. Supposedly, once the IR uses the new symbol system, 
-  // this should no longer happen. This version should be removed once that is resolved.
   lazy val freeVarsLLIR: Set[Local] = this match
     case Match(scrut, arms, dflt, rest) =>
       scrut.freeVarsLLIR ++ dflt.toList.flatMap(_.freeVarsLLIR) ++ rest.freeVarsLLIR
       ++ arms.flatMap:
-        (pat, arm) => arm.freeVarsLLIR -- pat.freeVars
+        (pat, arm) => arm.freeVarsLLIR -- pat.freeVarsLLIR
     case Return(res, implct) => res.freeVarsLLIR
     case Throw(exc) => exc.freeVarsLLIR
     case Label(label, body, rest) => (body.freeVarsLLIR - label) ++ rest.freeVarsLLIR 
-    case Break(label) => Set(label)
-    case Continue(label) => Set(label)
+    case Break(label) => Set.empty
+    case Continue(label) => Set.empty
     case Begin(sub, rest) => sub.freeVarsLLIR ++ rest.freeVarsLLIR
     case TryBlock(sub, finallyDo, rest) => sub.freeVarsLLIR ++ finallyDo.freeVarsLLIR ++ rest.freeVarsLLIR
-    case Assign(lhs, rhs, rest) => Set(lhs) ++ rhs.freeVarsLLIR ++ rest.freeVarsLLIR
+    case Assign(lhs, rhs, rest) => rhs.freeVarsLLIR ++ (rest.freeVarsLLIR - lhs)
     case AssignField(lhs, nme, rhs, rest) => lhs.freeVarsLLIR ++ rhs.freeVarsLLIR ++ rest.freeVarsLLIR
     case AssignDynField(lhs, fld, arrayIdx, rhs, rest) => lhs.freeVarsLLIR ++ fld.freeVarsLLIR ++ rhs.freeVarsLLIR ++ rest.freeVarsLLIR
-    case Define(defn, rest) => defn.freeVarsLLIR ++ rest.freeVarsLLIR
+    case Define(defn, rest) => defn.freeVarsLLIR ++ (rest.freeVarsLLIR - defn.sym)
     case HandleBlock(lhs, res, par, args, cls, hdr, bod, rst) =>
-      (bod.freeVarsLLIR - lhs) ++ rst.freeVarsLLIR ++ hdr.flatMap(_.freeVars)
+      (bod.freeVarsLLIR - lhs) ++ rst.freeVarsLLIR ++ hdr.flatMap(_.freeVarsLLIR)
     case End(msg) => Set.empty
 
   lazy val subBlocks: Ls[Block] = this match
@@ -385,8 +382,8 @@ final case class Handler(
     params: Ls[ParamList],
     body: Block,
 ):
-  lazy val freeVarsLLIR: Set[Local] = body.freeVarsLLIR -- params.flatMap(_.paramSyms) - sym - resumeSym
   lazy val freeVars: Set[Local] = body.freeVars -- params.flatMap(_.paramSyms) - sym - resumeSym
+  lazy val freeVarsLLIR: Set[Local] = body.freeVarsLLIR -- params.flatMap(_.paramSyms) - sym - resumeSym
 
 /* Represents either unreachable code (for functions that must return a result)
  * or the end of a non-returning function or a REPL block */
@@ -446,9 +443,13 @@ sealed abstract class Result extends AutoLocated:
     case Value.Rcd(args) => args.flatMap(arg => arg.idx.fold(Set.empty)(_.freeVars) ++ arg.value.freeVars).toSet
 
   lazy val freeVarsLLIR: Set[Local] = this match
-    case Call(fun, args) => args.flatMap(_.value.freeVarsLLIR).toSet
-    case Instantiate(cls, args) => args.flatMap(_.freeVarsLLIR).toSet
+    case Call(fun, args) => fun.freeVarsLLIR ++ args.flatMap(_.value.freeVarsLLIR).toSet
+    case Instantiate(cls, args) => cls.freeVarsLLIR ++ args.flatMap(_.freeVarsLLIR).toSet
     case Select(qual, name) => qual.freeVarsLLIR 
+    case Value.Ref(l: (BuiltinSymbol | TopLevelSymbol | ClassSymbol | TermSymbol)) => Set.empty
+    case Value.Ref(l: MemberSymbol[?]) => l.defn match
+      case Some(d: ClassLikeDef) => Set.empty
+      case _ => Set(l)
     case Value.Ref(l) => Set(l)
     case Value.This(sym) => Set.empty
     case Value.Lit(lit) => Set.empty

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

@@ -31,7 +31,7 @@ object Printer:
         .map{ case (c, b) => doc"${case_doc(c)} => #{  # ${mkDocument(b)} #} " }
         .mkDocument(sep = doc" # ")
       val docDefault = dflt.map(mkDocument).getOrElse(doc"")
-      doc"match ${mkDocument(scrut)} #{  # ${docCases} # else #{  # ${docDefault} #}  #}  # in # ${mkDocument(rest)} "
+      doc"match ${mkDocument(scrut)} #{  # ${docCases} # else #{  # ${docDefault} #}  #}  # in # ${mkDocument(rest)}"
     case Return(res, implct) => doc"return ${mkDocument(res)}"
     case Throw(exc) => doc"throw ${mkDocument(exc)}"
     case Label(label, body, rest) =>

hkmc2/shared/src/main/scala/hkmc2/codegen/cpp/Ast.scala

@@ -1,14 +1,13 @@
-package hkmc2.codegen.cpp
+package hkmc2
+package codegen.cpp
 
 import mlscript._
 import mlscript.utils._
 import mlscript.utils.shorthands._
-
-import hkmc2.Message.MessageContext
-import hkmc2.document._
-
 import scala.language.implicitConversions
 
+import document._
+
 private def raw(x: String): Document = doc"$x"
 given Conversion[String, Document] = x => doc"$x"
 
@@ -130,14 +129,13 @@ enum Expr:
   case Unary(op: Str, expr: Expr)
   case Binary(op: Str, lhs: Expr, rhs: Expr)
   case Initializer(exprs: Ls[Expr])
-  case Constructor(name: Str, init: Expr)
 
   def toDocument: Document =
     def aux(x: Expr): Document = x match
       case Var(name) => name
       case IntLit(value) => value.toString
       case DoubleLit(value) => value.toString
-      case StrLit(value) => s"\"$value\"" // need more reliable escape utils
+      case StrLit(value) => value.escaped
       case CharLit(value) => value.toInt.toString
       case Call(func, args) =>
         doc"${func.toDocument}(${Expr.toDocuments(args, sep = ", ")})"
@@ -151,8 +149,6 @@ enum Expr:
         doc"(${lhs.toDocument} $op ${rhs.toDocument})"
       case Initializer(exprs) => 
         doc"{${Expr.toDocuments(exprs, sep = ", ")}}"
-      case Constructor(name, init) =>
-        doc"$name(${init.toDocument})"
     aux(this)
 
 case class CompilationUnit(includes: Ls[Str], decls: Ls[Decl], defs: Ls[Def]):
@@ -161,57 +157,63 @@ case class CompilationUnit(includes: Ls[Str], decls: Ls[Decl], defs: Ls[Def]):
   def toDocumentWithoutHidden: Document =
     val hiddenNames: Set[Str] = Set()
     defs.filterNot { 
-      case Def.StructDef(name, _, _, _) => hiddenNames.contains(name.stripPrefix("_mls_"))
+      case Def.StructDef(name, _, _, _, _) => hiddenNames.contains(name.stripPrefix("_mls_"))
       case _ => false
     }.map(_.toDocument).mkDocument(doc" # ")
 
 enum Decl:
   case StructDecl(name: Str)
   case EnumDecl(name: Str)
-  case FuncDecl(ret: Type, name: Str, args: Ls[Type])
+  case FuncDecl(ret: Type, name: Str, args: Ls[Type], isOverride: Bool, isVirtual: Bool)
   case VarDecl(name: Str, typ: Type)
 
   def toDocument: Document =
     def aux(x: Decl): Document = x match
       case StructDecl(name) => doc"struct $name;"
       case EnumDecl(name) => doc"enum $name;"
-      case FuncDecl(ret, name, args) =>
-        doc"${ret.toDocument()} $name(${Type.toDocuments(args, sep = ", ")});"
+      case FuncDecl(ret, name, args, or, virt) =>
+        val docVirt = (if virt then doc"virtual " else doc"")
+        val docSpecRet = ret.toDocument()
+        val docArgs = Type.toDocuments(args, sep = ", ")
+        val docOverride = if or then doc" override" else doc""
+        doc"$docVirt$docSpecRet $name($docArgs)$docOverride;"
       case VarDecl(name, typ) => 
         doc"${typ.toDocument()} $name;"
     aux(this)
 
 enum Def:
-  case StructDef(name: Str, fields: Ls[(Str, Type)], inherit: Opt[Ls[Str]], methods: Ls[Def] = Ls.empty)
+  case StructDef(name: Str, fields: Ls[(Str, Type)], inherit: Opt[Ls[Str]], methods: Ls[Def], methodsDecl: Ls[Decl])
   case EnumDef(name: Str, fields: Ls[(Str, Opt[Int])])
-  case FuncDef(specret: Type, name: Str, args: Ls[(Str, Type)], body: Stmt.Block, or: Bool = false, virt: Bool = false)
+  case FuncDef(specret: Type, name: Str, args: Ls[(Str, Type)], body: Stmt.Block, isOverride: Bool, isVirtual: Bool, in_scope: Opt[Str])
   case VarDef(typ: Type, name: Str, init: Opt[Expr])
   case RawDef(raw: Str)
 
   def toDocument: Document =
     def aux(x: Def): Document = x match
-      case StructDef(name, fields, inherit, defs) =>
+      case StructDef(name, fields, inherit, defs, decls) =>
         val docFirst = doc"struct $name${inherit.fold(doc"")(x => doc": public ${x.mkDocument(doc", ")}")} {"
         val docFields = fields.map {
           case (name, typ) => doc"${typ.toDocument()} $name;"
         }.mkDocument(doc" # ")
         val docDefs = defs.map(_.toDocument).mkDocument(doc" # ")
+        val docDecls = decls.map(_.toDocument).mkDocument(doc" # ")
         val docLast = "};"
-        doc"$docFirst #{  # $docFields # $docDefs #}  # $docLast"
+        doc"$docFirst #{  # $docFields # $docDefs # $docDecls #}  # $docLast"
       case EnumDef(name, fields) =>
         val docFirst = doc"enum $name {"
         val docFields = fields.map {
           case (name, value) => value.fold(s"$name")(x => s"$name = $x")
         }.mkDocument(doc" # ")
         val docLast = "};"
         doc"$docFirst #{  # $docFields #}  # $docLast"
-      case FuncDef(specret, name, args, body, or, virt) =>
+      case FuncDef(specret, name, args, body, or, virt, scope) =>
         val docVirt = (if virt then doc"virtual " else doc"")
         val docSpecRet = specret.toDocument()
         val docArgs = Type.toDocuments(args, sep = ", ")
         val docOverride = if or then doc" override" else doc""
         val docBody = body.toDocument
-        doc"$docVirt$docSpecRet $name($docArgs)$docOverride ${body.toDocument}"
+        val docScope = scope.fold(doc"")(x => doc"$x::")
+        doc"$docVirt$docSpecRet $docScope$name($docArgs)$docOverride ${body.toDocument}"
       case VarDef(typ, name, init) =>
         val docTyp = typ.toDocument()
         val docInit = init.fold(raw(""))(x => doc" = ${x.toDocument}")