Use implicit conversion to avoid repeating raw

waterlens · waterlens · commit 3c66451b2c02 · 2024-07-31T19:42:56.000+08:00
diff --git a/compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala b/compiler/shared/main/scala/mlscript/compiler/codegen/CppAst.scala
@@ -5,6 +5,10 @@ import mlscript.utils._
 import mlscript.utils.shorthands._
 import mlscript.compiler.utils._
 
+import scala.language.implicitConversions
+
+given Conversion[String, Document] = raw
+
 enum Specifier:
   case Extern
   case Static
@@ -50,16 +54,16 @@ enum Type:
 
   def toDocument(extraTypename: Bool = false): Document =
     def aux(x: Type): Document = x match
-      case Prim(name) => name |> raw
-      case Ptr(inner) => aux(inner) <#> raw("*") 
-      case Ref(inner) => aux(inner) <#> raw("&")
-      case Array(inner, size) => aux(inner) <#> raw("[") <#> size.fold(raw(""))(x => x.toString |> raw) <#> raw("]")
-      case FuncPtr(ret, args) => aux(ret) <#> raw("(") <#> Type.toDocuments(args, sep = raw(", ")) <#> raw(")")
-      case Struct(name) => raw(s"struct $name")
-      case Enum(name) => raw(s"enum $name")
-      case Template(name, args) => raw(s"$name") <#> raw("<") <#> Type.toDocuments(args, sep = raw(", ")) <#> raw(">")
-      case Var(name) => name |> raw
-      case Qualifier(inner, qual) => aux(inner) <:> raw(qual)
+      case Prim(name) => name
+      case Ptr(inner) => aux(inner) <#> "*" 
+      case Ref(inner) => aux(inner) <#> "&"
+      case Array(inner, size) => aux(inner) <#> "[" <#> size.fold(raw(""))(x => x.toString) <#> "]"
+      case FuncPtr(ret, args) => aux(ret) <#> "(" <#> Type.toDocuments(args, sep = ", ") <#> ")"
+      case Struct(name) => s"struct $name"
+      case Enum(name) => s"enum $name"
+      case Template(name, args) => s"$name" <#> "<" <#> Type.toDocuments(args, sep = ", ") <#> ">"
+      case Var(name) => name
+      case Qualifier(inner, qual) => aux(inner) <:> qual
     aux(this)
 
   override def toString: Str = toDocument().print
@@ -87,28 +91,29 @@ enum Stmt:
       case AutoBind(lhs, rhs) =>
         lhs match
           case Nil => rhs.toDocument
-          case x :: Nil => raw("auto") <:> raw(x) <:> raw("=") <:> rhs.toDocument <#> raw(";")
-          case _ => raw("auto") <:> raw(lhs.mkString("[", ",", "]")) <:> raw("=") <:> rhs.toDocument <#> raw(";")
-      case Assign(lhs, rhs) => raw(lhs) <#> raw(" = ") <#> rhs.toDocument <#> raw(";")
-      case Return(expr) => raw("return ") <#> expr.toDocument <#> raw(";")
+          case x :: Nil => "auto" <:> x <:> "=" <:> rhs.toDocument <#> ";"
+          case _ => "auto" <:> lhs.mkString("[", ",", "]") <:> "=" <:> rhs.toDocument <#> ";"
+      case Assign(lhs, rhs) => lhs <#> " = " <#> rhs.toDocument <#> ";"
+      case Return(expr) => "return " <#> expr.toDocument <#> ";"
       case If(cond, thenStmt, elseStmt) =>
-        raw("if (") <#> cond.toDocument <#> raw(")") <#> thenStmt.toDocument <:> elseStmt.fold(raw(""))(x => raw("else") <:> x.toDocument)
+        "if (" <#> cond.toDocument <#> ")" <#> thenStmt.toDocument <:> elseStmt.fold(raw(""))(x => "else" <:> x.toDocument)
       case While(cond, body) =>
-        raw("while (") <#> cond.toDocument <#> raw(")") <#> body.toDocument
+        "while (" <#> cond.toDocument <#> ")" <#> body.toDocument
       case For(init, cond, update, body) =>
-        raw("for (") <#> init.toDocument <#> raw("; ") <#> cond.toDocument <#> raw("; ") <#> update.toDocument <#> raw(")") <#> body.toDocument
-      case ExprStmt(expr) => expr.toDocument <#> raw(";")
-      case Break => raw("break;")
-      case Continue => raw("continue;")
+        "for (" <#> init.toDocument <#> "; " <#> cond.toDocument <#> "; " <#> update.toDocument <#> ")" <#> body.toDocument
+      case ExprStmt(expr) => expr.toDocument <#> ";"
+      case Break => "break;"
+      case Continue => "continue;"
       case Block(decl, stmts) => 
-        stack(raw("{"),
+        stack(
+          "{",
           Stmt.toDocuments(decl, stmts) |> indent,
-        raw("}"))
+          "}")
       case Switch(expr, cases) =>
-        raw("switch (") <#> expr.toDocument <#> raw(")") <#> raw("{") <#> stack_list(cases.map {
-          case (cond, stmt) => raw("case ") <#> cond.toDocument <#> raw(":") <#> stmt.toDocument
-        }) <#> raw("}")
-      case Raw(stmt) => stmt |> raw
+        "switch (" <#> expr.toDocument <#> ")" <#> "{" <#> stack_list(cases.map {
+          case (cond, stmt) => "case " <#> cond.toDocument <#> ":" <#> stmt.toDocument
+        }) <#> "}"
+      case Raw(stmt) => stmt
     aux(this)
 
 object Expr:
@@ -135,18 +140,18 @@ enum Expr:
 
   def toDocument: Document =
     def aux(x: Expr): Document = x match
-      case Var(name) => name |> raw
-      case IntLit(value) => value.toString |> raw
-      case DoubleLit(value) => value.toString |> raw
-      case StrLit(value) => s"\"$value\"" |> raw // need more reliable escape utils
-      case CharLit(value) => value.toInt.toString |> raw
-      case Call(func, args) => aux(func) <#> raw("(") <#> Expr.toDocuments(args, sep = raw(", ")) <#> raw(")")
-      case Member(expr, member) => aux(expr) <#> raw("->") <#> raw(member)
-      case Index(expr, index) => aux(expr) <#> raw("[") <#> aux(index) <#> raw("]")
-      case Unary(op, expr) => raw("(") <#> raw(op) <#> aux(expr) <#> raw(")")
-      case Binary(op, lhs, rhs) => raw("(") <#> aux(lhs) <#> raw(op) <#> aux(rhs) <#> raw(")")
-      case Initializer(exprs) => raw("{") <#> Expr.toDocuments(exprs, sep = raw(", ")) <#> raw("}")
-      case Constructor(name, init) => raw(name) <#> init.toDocument
+      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 CharLit(value) => value.toInt.toString
+      case Call(func, args) => aux(func) <#> "(" <#> Expr.toDocuments(args, sep = ", ") <#> ")"
+      case Member(expr, member) => aux(expr) <#> "->" <#> member
+      case Index(expr, index) => aux(expr) <#> "[" <#> aux(index) <#> "]"
+      case Unary(op, expr) => "(" <#> op <#> aux(expr) <#> ")"
+      case Binary(op, lhs, rhs) => "(" <#> aux(lhs) <#> op <#> aux(rhs) <#> ")"
+      case Initializer(exprs) => "{" <#> Expr.toDocuments(exprs, sep = ", ") <#> "}"
+      case Constructor(name, init) => name <#> init.toDocument
     aux(this)
 
 case class CompilationUnit(includes: Ls[Str], decls: Ls[Decl], defs: Ls[Def]):
@@ -161,10 +166,10 @@ enum Decl:
 
   def toDocument: Document =
     def aux(x: Decl): Document = x match
-      case StructDecl(name) => raw(s"struct $name;")
-      case EnumDecl(name) => raw(s"enum $name;")
-      case FuncDecl(ret, name, args) => ret.toDocument() <#> raw(s" $name(") <#> Type.toDocuments(args, sep = raw(", "))  <#> raw(");")
-      case VarDecl(name, typ) => typ.toDocument() <#> raw(s" $name;")
+      case StructDecl(name) => s"struct $name;"
+      case EnumDecl(name) => s"enum $name;"
+      case FuncDecl(ret, name, args) => ret.toDocument() <#> s" $name(" <#> Type.toDocuments(args, sep = ", ")  <#> ");"
+      case VarDecl(name, typ) => typ.toDocument() <#> s" $name;"
     aux(this)
 
 enum Def:
@@ -178,21 +183,21 @@ enum Def:
     def aux(x: Def): Document = x match
       case StructDef(name, fields, inherit, defs) =>
         stack(
-          raw(s"struct $name") <#> (if inherit.nonEmpty then raw(": public") <:> raw(inherit.get.mkString(", ")) else raw("") ) <:> raw("{"),
+          s"struct $name" <#> (if inherit.nonEmpty then ": public" <:> inherit.get.mkString(", ") else "" ) <:> "{",
             stack_list(fields.map {
-                case (name, typ) => typ.toDocument() <#> raw(" ") <#> raw(name) <#> raw(";")
+                case (name, typ) => typ.toDocument() <#> " " <#> name <#> ";"
             }) |> indent,
             stack_list(defs.map(_.toDocument)) |> indent,
-          raw("};")
+          "};"
         )
       case EnumDef(name, fields) =>
-        raw(s"enum $name") <:> raw("{") <#> stack_list(fields.map {
-          case (name, value) => value.fold(raw(s"$name"))(x => raw(s"$name = $x"))
-        }) <#> raw("};")
+        s"enum $name" <:> "{" <#> stack_list(fields.map {
+          case (name, value) => value.fold(s"$name")(x => s"$name = $x")
+        }) <#> "};"
       case FuncDef(specret, name, args, body, or, virt) =>
-        (if virt then raw("virtual ") else raw("")) 
-        <#> specret.toDocument() <#> raw(s" $name(") <#> Type.toDocuments(args, sep = raw(", ")) <#> raw(")") <#> (if or then raw(" override") else raw("")) <#> body.toDocument
+        (if virt then "virtual " else "") 
+        <#> specret.toDocument() <#> s" $name(" <#> Type.toDocuments(args, sep = ", ") <#> ")" <#> (if or then " override" else "") <#> body.toDocument
       case VarDef(typ, name, init) =>
-        typ.toDocument() <#> raw(s" $name") <#> init.fold(raw(""))(x => raw(" = ") <#> x.toDocument) <#> raw(";")
-      case RawDef(x) => x |> raw
+        typ.toDocument() <#> s" $name" <#> init.fold(raw(""))(x => " = " <#> x.toDocument) <#> raw(";")
+      case RawDef(x) => x
     aux(this)
diff --git a/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala b/compiler/shared/main/scala/mlscript/compiler/ir/IR.scala
@@ -11,6 +11,7 @@ import collection.mutable.{Map as MutMap, Set as MutSet, HashMap, ListBuffer}
 import annotation.unused
 import util.Sorting
 import scala.collection.immutable.SortedSet
+import scala.language.implicitConversions
 
 final case class IRError(message: String) extends Exception(message)
 
@@ -126,19 +127,21 @@ enum Expr:
   def show: String =
     toDocument.print
   
-  def toDocument: Document = this match
-    case Ref(s) => s.toString |> raw
-    case Literal(IntLit(lit)) => s"$lit" |> raw
-    case Literal(DecLit(lit)) => s"$lit" |> raw
-    case Literal(StrLit(lit)) => s"$lit" |> raw
-    case Literal(CharLit(lit)) => s"$lit" |> raw
-    case Literal(UnitLit(lit)) => s"$lit" |> raw
+  def toDocument: Document = 
+    given Conversion[String, Document] = raw
+    this match
+    case Ref(s) => s.toString
+    case Literal(IntLit(lit)) => s"$lit"
+    case Literal(DecLit(lit)) => s"$lit"
+    case Literal(StrLit(lit)) => s"$lit"
+    case Literal(CharLit(lit)) => s"$lit"
+    case Literal(UnitLit(lit)) => s"$lit"
     case CtorApp(cls, args) =>
-      raw(cls.name) <#> raw("(") <#> raw(args |> showArguments) <#> raw(")")
+      cls.name <#> "(" <#> (args |> showArguments) <#> ")"
     case Select(s, cls, fld) =>
-      raw(cls.name) <#> raw(".") <#> raw(fld) <#> raw("(") <#> raw(s.toString) <#> raw(")")
+      cls.name <#> "." <#> fld <#> "(" <#> s.toString <#> ")"
     case BasicOp(name: Str, args) =>
-      raw(name) <#> raw("(") <#> raw(args |> showArguments) <#> raw(")")
+      name <#> "(" <#> (args |> showArguments) <#> ")"
 
   def mapName(f: Name => Name): Expr = this match
     case Ref(name) => Ref(f(name))
@@ -221,67 +224,69 @@ enum Node:
       val names_copy = names.map(_.copy)
       LetCall(names_copy, defn, args.map(_.mapNameOfTrivialExpr(_.trySubst(ctx))), body.copy(ctx ++ names_copy.map(x => x.str -> x)))
 
-  private def toDocument: Document = this match
-    case Result(res) => raw(res |> showArguments) <:> raw(s"-- $tag")
+  private def toDocument: Document =
+    given Conversion[String, Document] = raw
+    this match
+    case Result(res) => (res |> showArguments) <:> s"-- $tag"
     case Jump(jp, args) =>
-      raw("jump")
-      <:> raw(jp.name)
-      <#> raw("(")
-      <#> raw(args |> showArguments)
-      <#> raw(")")
-      <:> raw(s"-- $tag") 
+      "jump"
+      <:> jp.name
+      <#> "("
+      <#> (args |> showArguments)
+      <#> ")"
+      <:> s"-- $tag" 
     case Case(x, Ls((tpat, tru), (fpat, fls)), N) if tpat.isTrue && fpat.isFalse =>
-      val first = raw("if") <:> raw(x.toString) <:> raw(s"-- $tag") 
-      val tru2 = indent(stack(raw("true") <:> raw ("=>"), tru.toDocument |> indent))
-      val fls2 = indent(stack(raw("false") <:> raw ("=>"), fls.toDocument |> indent))
+      val first = "if" <:> x.toString <:> s"-- $tag" 
+      val tru2 = indent(stack("true" <:> "=>", tru.toDocument |> indent))
+      val fls2 = indent(stack("false" <:> "=>", fls.toDocument |> indent))
       Document.Stacked(Ls(first, tru2, fls2))
     case Case(x, cases, default) =>
-      val first = raw("case") <:> raw(x.toString) <:> raw("of") <:> raw(s"-- $tag") 
+      val first = "case" <:> x.toString <:> "of" <:> s"-- $tag" 
       val other = cases flatMap {
         case (pat, node) =>
-          Ls(raw(pat.toString) <:> raw("=>"), node.toDocument |> indent)
+          Ls(pat.toString <:> "=>", node.toDocument |> indent)
       }
       default match
         case N => stack(first, (Document.Stacked(other) |> indent))
         case S(dc) =>
-          val default = Ls(raw("_") <:> raw("=>"), dc.toDocument |> indent)
+          val default = Ls("_" <:> "=>", dc.toDocument |> indent)
           stack(first, (Document.Stacked(other ++ default) |> indent))
     case LetExpr(x, expr, body) => 
       stack(
-        raw("let")
-          <:> raw(x.toString)
-          <:> raw("=")
+        "let"
+          <:> x.toString
+          <:> "="
           <:> expr.toDocument
-          <:> raw("in")
-          <:> raw(s"-- $tag"),
+          <:> "in"
+          <:> s"-- $tag",
         body.toDocument)
     case LetMethodCall(xs, cls, method, args, body) =>
       stack(
-        raw("let")
-          <:> raw(xs.map(_.toString).mkString(","))
-          <:> raw("=")
-          <:> raw(cls.name)
-          <#> raw(".")
-          <#> raw(method.toString)
-          <#> raw("(")
-          <#> raw(args.map{ x => x.toString }.mkString(","))
-          <#> raw(")")
-          <:> raw("in") 
-          <:> raw(s"-- $tag"),
+        "let"
+          <:> xs.map(_.toString).mkString(",")
+          <:> "="
+          <:> cls.name
+          <#> "."
+          <#> method.toString
+          <#> "("
+          <#> args.map{ x => x.toString }.mkString(",")
+          <#> ")"
+          <:> "in" 
+          <:> s"-- $tag",
         body.toDocument)
     case LetCall(xs, defn, args, body) => 
       stack(
-        raw("let*")
-          <:> raw("(")
-          <#> raw(xs.map(_.toString).mkString(","))
-          <#> raw(")")
-          <:> raw("=")
-          <:> raw(defn.name)
-          <#> raw("(")
-          <#> raw(args.map{ x => x.toString }.mkString(","))
-          <#> raw(")")
-          <:> raw("in") 
-          <:> raw(s"-- $tag"),
+        "let*"
+          <:> "("
+          <#> xs.map(_.toString).mkString(",")
+          <#> ")"
+          <:> "="
+          <:> defn.name
+          <#> "("
+          <#> args.map{ x => x.toString }.mkString(",")
+          <#> ")"
+          <:> "in" 
+          <:> s"-- $tag",
         body.toDocument)
   
   def locMarker: LocMarker =
@@ -484,44 +489,46 @@ enum LocMarker:
   case MLetCall(names: Ls[Str], defn: Str, args: Ls[LocMarker])
   var tag = DefnTag(-1)
 
-  def toDocument: Document = this match
-    case MResult(res) => raw("...")
+  def toDocument: Document = 
+    given Conversion[String, Document] = raw
+    this match
+    case MResult(res) => "..."
     case MJump(jp, args) =>
-      raw("jump")
-      <:> raw(jp)
-      <:> raw("...")
+      "jump"
+      <:> jp
+      <:> "..."
     case MCase(x, Ls(tpat, fpat), false) if tpat.isTrue && fpat.isFalse =>
-      raw("if") <:> raw(x.toString) <:> raw("...")
+      "if" <:> x.toString <:> "..."
     case MCase(x, cases, default) =>
-      raw("case") <:> raw(x.toString) <:> raw("of") <:> raw("...")
+      "case" <:> x.toString <:> "of" <:> "..."
     case MLetExpr(x, expr) => 
-      raw("let")
-        <:> raw(x.toString)
-        <:> raw("=")
-        <:> raw("...")
+      "let"
+        <:> x.toString
+        <:> "="
+        <:> "..."
     case MLetMethodCall(xs, cls, method, args) =>
-      raw("let")
-        <:> raw(xs.map(_.toString).mkString(","))
-        <:> raw("=")
-        <:> raw(cls.name)
-        <:> raw(".")
-        <:> raw(method)
-        <:> raw("...")
+      "let"
+        <:> xs.map(_.toString).mkString(",")
+        <:> "="
+        <:> cls.name
+        <:> "."
+        <:> method
+        <:> "..."
     case MLetCall(xs, defn, args) =>
-      raw("let*")
-        <:> raw("(")
-        <#> raw(xs.map(_.toString).mkString(","))
-        <#> raw(")")
-        <:> raw("=")
-        <:> raw(defn)
-        <:> raw("...")
-    case MRef(s) => s.toString |> raw
-    case MLit(IntLit(lit)) => s"$lit" |> raw
-    case MLit(DecLit(lit)) => s"$lit" |> raw
-    case MLit(StrLit(lit)) => s"$lit" |> raw
-    case MLit(CharLit(lit)) => s"$lit" |> raw
-    case MLit(UnitLit(undefinedOrNull)) => (if undefinedOrNull then "undefined" else "null") |> raw
-    case _ => raw("...")
+      "let*"
+        <:> "("
+        <#> xs.map(_.toString).mkString(",")
+        <#> ")"
+        <:> "="
+        <:> defn
+        <:> "..."
+    case MRef(s) => s.toString
+    case MLit(IntLit(lit)) => s"$lit"
+    case MLit(DecLit(lit)) => s"$lit"
+    case MLit(StrLit(lit)) => s"$lit"
+    case MLit(CharLit(lit)) => s"$lit"
+    case MLit(UnitLit(undefinedOrNull)) => if undefinedOrNull then "undefined" else "null"
+    case _ => "..."
 
   def show = s"$tag-" + toDocument.print
 
