Fixing errors caused by rebase

Author: Oli-Ar

hkmc2/shared/src/main/scala/hkmc2/MLsCompiler.scala

@@ -52,22 +52,6 @@ class MLsCompiler(preludeFile: os.Path):
   var dbgParsing = false
 
   def compileModule(file: os.Path): Unit =
-
-    val block = os.read(file)
-    val fph = new FastParseHelpers(block)
-    val origin = Origin(file.toString, 0, fph)
-
-    val lexer = new syntax.Lexer(origin, dbg = dbgParsing)
-    val tokens = lexer.bracketedTokens
-
-    // if showParse.isSet || dbgParsing.isSet then
-    //   output(syntax.Lexer.printTokens(tokens))
-
-    val p = new syntax.Parser(origin, tokens, raise, dbg = dbgParsing):
-      def doPrintDbg(msg: => Str): Unit =
-        // if dbg then output(msg)
-        if dbg then println(msg)
-    val res = p.parseAll(p.block(allowNewlines = true))
     given Elaborator.State = new Elaborator.State
 
     val preludeParse = ParserSetup(preludeFile, dbgParsing)

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

@@ -904,7 +904,7 @@ extends Importer:
       ps
     case _ =>
       t.asParam.map: (isSpd, p, st) =>
-        isSpd -> Param(FldFlags.fromTerm(t), fieldOrVarSym(ParamBind, p), st.map(term))
+        isSpd -> Param(FldFlags.fromTerm(t), fieldOrVarSym(ParamBind, p), st.map(term(_)))
 
   def params(t: Tree): Ctxl[(ParamList, Ctx)] = t match
     case Tup(ps) =>

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

@@ -37,12 +37,12 @@ class Specialiser(val tl: TraceLogger, val ctx: Ctx)(using val raise: Raise, val
     term match
       case Blk(Nil, res) => collectDefs(res)
       case Blk((d: Declaration) :: stats, res) => collectDefs(Blk(stats, res)) ++ (d match
-        case td@TermDefinition(_, Fun, sym, params, _, Some(body), _) =>
+        case td@TermDefinition(_, Fun, sym, params, _, Some(body), _, _, _) =>
           val map = collectDefs(body) ++ collectDefs(Blk(stats, res))
           if params.flatMap(_.params).exists(_.flags.spec) then map + (td.sym -> td) else map
         case _ => d.subTerms.foldLeft(Map.empty[Symbol, TermDefinition])((acc, sub) => acc ++ collectDefs(sub)))
       case Blk((t: Term) :: stats, res) => collectDefs(t) ++ collectDefs(Blk(stats, res))
-      case Blk(LetDecl(_) :: stats, res) => collectDefs(Blk(stats, res))
+      case Blk(LetDecl(_, _) :: stats, res) => collectDefs(Blk(stats, res))
       case Blk(DefineVar(_, rhs) :: stats, res) => collectDefs(rhs) ++ collectDefs(Blk(stats, res))
       case _ => term.subTerms.foldLeft(Map.empty)((acc, sub) => acc ++ collectDefs(sub))
 
@@ -59,14 +59,13 @@ class Specialiser(val tl: TraceLogger, val ctx: Ctx)(using val raise: Raise, val
           case s => (acc._1 :+ s, acc._2)
     collectApps(tree.res) match { case (res, ts) => (Blk(stats, res), types ::: ts) }
 
-  // TODO: Make specFns immutable so this can be nice and pure
   def collectApps(tree: Term)(using defs: Map[Symbol, TermDefinition], specFns: MutMap[Str, Ident]): Ctxl[(Term, Ls[SpApp])] =
     trace(s"Collecting term ${tree.showDbg}"):
       tree match
         case app@App(lhs, Tup(fields)) => lhs match
           case s@Sel(pre, nme) =>
             if s.sym.isDefined && defs.contains(s.sym.get) then
-              val typs = defs(s.sym.get).params.flatMap(_.params).zip(fields.map(_.value).map {
+              val typs = defs(s.sym.get).params.flatMap(_.params).zip(fields.filter(e => e.isInstanceOf[Fld]).map(_.asInstanceOf[Fld].term).map {
                 case Lit(lit) => lit.asTree match
                   case _: IntLit => "Int"
                   case _: StrLit => "Str"
@@ -75,13 +74,13 @@ class Specialiser(val tl: TraceLogger, val ctx: Ctx)(using val raise: Raise, val
               }).filter(_._1.flags.spec)
               log(s"Specialising ${s.sym.get} with ${typs.map((s, t) => s.sym.nme + ": " + t)}.")
               val fId = s.sym.get.nme + typs.map(_._2).mkString("_", "_", "")
-              val name = specFns.getOrElseUpdate(fId, Ident(fId + "_" + state.nextUid)) // not sure state is the way to do this
+              val name = specFns.getOrElseUpdate(fId, Ident(fId + "_" + state.suid.nextUid))
               val specApp: App = app.copy(lhs = s.copy(nme = name)(s.sym))(app.tree, app.resSym)
               (specApp, SpApp(s.sym.get, typs.foldLeft(Map.empty)((acc, p) => acc + (p._1.sym -> p._2)), specApp) :: Nil)
             else
               (tree, Nil)
           // FIXME: Ref applications aren't implemented, nor do I know when they are used
-          case Ref(sym) => if defs.contains(sym) then (tree, SpApp(TempSymbol(999, N, ""), Map.empty, app) :: Nil) else (tree, Nil)
+          case Ref(sym) => if defs.contains(sym) then (tree, SpApp(TempSymbol(N, ""), Map.empty, app) :: Nil) else (tree, Nil)
           case _ => (tree, Nil)
         case b: Blk => collectApps(b)
         // FIXME: This won't work for nested applications in all cases

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

@@ -359,8 +359,9 @@ object FldFlags:
   val empty: FldFlags = FldFlags(false, false, false, false)
 
   def fromTerm(t: Tree): FldFlags = t match
-    case Tree.Modified(Keyword.`mut`, _, b) => FldFlags(true, false, false).addFlags(b)
-    case Tree.Modified(Keyword.`spec`, _, b) => FldFlags(false, true, false).addFlags(b)
+    case Tree.Modified(Keyword.`mut`, _, b) => FldFlags(true, false, false, false).addFlags(b)
+    case Tree.Modified(Keyword.`spec`, _, b) => FldFlags(false, true, false, false).addFlags(b)
+    case Tree.Modified(Keyword.`module`, _, b) => FldFlags(false, false, false, true).addFlags(b)
     case _ => empty
 
 sealed abstract class Elem:

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

@@ -189,7 +189,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
-    case Modified(_, _, inner) => inner.param
+    case Modified(_, _, inner) => inner.asParam
 
   def isModuleModifier: Bool = this match
     case Tree.TypeDef(Mod, _, N, N) => true