Merge pull request #157 from chengluyu/ucs-paper

Improvements and fixes for UCS

Author: LPTK

.github/workflows/scala.yml

@@ -4,7 +4,6 @@ on:
   push:
     branches: [ mlscript ]
   pull_request:
-    branches: [ mlscript ]
 
 jobs:
   build:

.gitignore

@@ -7,3 +7,4 @@ metals.sbt
 project/Dependencies.scala
 project/metals.sbt
 **.worksheet.sc
+.DS_Store

.vscode/settings.json

@@ -1,7 +1,6 @@
 {
     "files.associations": {
-        "*.fun": "typescript",
-        "*.mls": "scala"
+        "*.fun": "typescript"
     },
     "typescript.validate.enable": false,
     "files.watcherExclude": {

js/src/main/scala/Main.scala

@@ -134,7 +134,7 @@ object Main {
 
           val vars: Map[Str, typer.SimpleType] = Map.empty
           val tpd = typer.typeTypingUnit(tu, topLevel = true)(ctx.nest, raise, vars)
-
+          
           object SimplifyPipeline extends typer.SimplifyPipeline {
             def debugOutput(msg: => Str): Unit =
               // if (mode.dbgSimplif) output(msg)

shared/src/main/scala/mlscript/NewLexer.scala

@@ -55,6 +55,34 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
   def takeWhile(i: Int, cur: Ls[Char] = Nil)(pred: Char => Bool): (Str, Int) =
     if (i < length && pred(bytes(i))) takeWhile(i + 1, bytes(i) :: cur)(pred)
     else (cur.reverseIterator.mkString, i)
+
+  @tailrec final
+  def str(i: Int, escapeMode: Bool, cur: Ls[Char] = Nil): (Str, Int) =
+    if (escapeMode)
+      if (i < length)
+        bytes(i) match {
+          case '"' => str(i + 1, false, '"' :: cur)
+          case 'n' => str(i + 1, false, '\n' :: cur)
+          case 't' => str(i + 1, false, '\t' :: cur)
+          case 'r' => str(i + 1, false, '\r' :: cur)
+          case ch =>
+            raise(WarningReport(msg"Found invalid escape character" -> S(loc(i, i + 1)) :: Nil, source = Lexing))
+            str(i + 1, false, ch :: cur)
+        }
+      else {
+        raise(ErrorReport(msg"Expect an escape character" -> S(loc(i, i + 1)) :: Nil, source = Lexing))
+        (cur.reverseIterator.mkString, i)
+      }
+    else {
+      if (i < length)
+        bytes(i) match {
+          case '\\' => str(i + 1, true, cur)
+          case '"' | '\n' => (cur.reverseIterator.mkString, i)
+          case ch => str(i + 1, false, ch :: cur)
+        }
+      else
+        (cur.reverseIterator.mkString, i)
+    }
 
   def loc(start: Int, end: Int): Loc = Loc(start, end, origin)
 
@@ -78,7 +106,7 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
         lex(j, ind, next(j, COMMA))
       case '"' =>
         val j = i + 1
-        val (chars, k) = takeWhile(j)(c => c =/= '"' && c =/= '\n')
+        val (chars, k) = str(j, false)
         val k2 = if (bytes.lift(k) === Some('"')) k + 1 else {
           pe(msg"unclosed quotation mark")
           k
@@ -135,14 +163,19 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
         // go(j, if (keywords.contains(n)) KEYWORD(n) else IDENT(n, isAlphaOp(n)))
         lex(j, ind, next(j, if (keywords.contains(n)) KEYWORD(n) else IDENT(n, isAlphaOp(n))))
       case _ if isOpChar(c) =>
-        val (n, j) = takeWhile(i)(isOpChar)
-        if (n === "." && j < length && isIdentFirstChar(bytes(j))) {
-          val (name, k) = takeWhile(j)(isIdentChar)
-          // go(k, SELECT(name))
-          lex(k, ind, next(k, SELECT(name)))
+        if (c === '-' && isDigit(bytes(i + 1))) {
+          val (str, j) = takeWhile(i + 1)(isDigit)
+          lex(j, ind, next(j, LITVAL(IntLit(-BigInt(str)))))
+        } else {
+          val (n, j) = takeWhile(i)(isOpChar)
+          if (n === "." && j < length && isIdentFirstChar(bytes(j))) {
+            val (name, k) = takeWhile(j)(isIdentChar)
+            // go(k, SELECT(name))
+            lex(k, ind, next(k, SELECT(name)))
+          }
+          // else go(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true))
+          else lex(j, ind, next(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true)))
         }
-        // else go(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true))
-        else lex(j, ind, next(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true)))
       case _ if isDigit(c) =>
         val (str, j) = takeWhile(i)(isDigit)
         // go(j, LITVAL(IntLit(BigInt(str))))

shared/src/main/scala/mlscript/Typer.scala

@@ -255,6 +255,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool)
     val intBinOpTy = fun(singleTup(IntType), fun(singleTup(IntType), IntType)(noProv))(noProv)
     val numberBinOpTy = fun(singleTup(DecType), fun(singleTup(DecType), DecType)(noProv))(noProv)
     val numberBinPred = fun(singleTup(DecType), fun(singleTup(DecType), BoolType)(noProv))(noProv)
+    val stringBinPred = fun(singleTup(StrType), fun(singleTup(StrType), BoolType)(noProv))(noProv)
     Map(
       "true" -> TrueType,
       "false" -> FalseType,
@@ -278,6 +279,10 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool)
       "le" -> numberBinPred,
       "gt" -> numberBinPred,
       "ge" -> numberBinPred,
+      "slt" -> stringBinPred,
+      "sle" -> stringBinPred,
+      "sgt" -> stringBinPred,
+      "sge" -> stringBinPred,
       "length" -> fun(singleTup(StrType), IntType)(noProv),
       "concat" -> fun(singleTup(StrType), fun(singleTup(StrType), StrType)(noProv))(noProv),
       "eq" -> {
@@ -1062,19 +1067,9 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool)
           case ((a_ty, tv), req) => a_ty & tv | req & a_ty.neg()
         }
         con(s_ty, req, cs_ty)
-      case iff @ If(body, fallback) =>
-        import mlscript.ucs._
-        try {
-          val caseTree = MutCaseOf.build(desugarIf(body, fallback))
-          println("The mutable CaseOf tree")
-          MutCaseOf.show(caseTree).foreach(println(_))
-          checkExhaustive(caseTree, N)(summarizePatterns(caseTree), ctx, raise)
-          val desugared = MutCaseOf.toTerm(caseTree)
-          println(s"Desugared term: ${desugared.print(false)}")
-          iff.desugaredTerm = S(desugared)
-          typeTerm(desugared)
-        } catch {
-          case e: DesugaringException => err(e.messages)
+      case elf: If =>
+        try typeTerm(desugarIf(elf)) catch {
+          case e: ucs.DesugaringException => err(e.messages)
         }
       case New(S((nmedTy, trm)), TypingUnit(Nil)) =>
         typeMonomorphicTerm(App(Var(nmedTy.base.name).withLocOf(nmedTy), trm))

shared/src/main/scala/mlscript/codegen/Polyfill.scala

@@ -166,6 +166,12 @@ object Polyfill {
     buffer += BuiltinFunc("not", makeUnaryFunc("!"))
     buffer += BuiltinFunc("negate", makeUnaryFunc("-"))
     buffer += BuiltinFunc("eq", makeBinaryFunc("==="))
+    buffer += BuiltinFunc("ne", makeBinaryFunc("!=="))
+    buffer += BuiltinFunc("sgt", makeBinaryFunc(">"))
+    buffer += BuiltinFunc("slt", makeBinaryFunc("<"))
+    buffer += BuiltinFunc("sge", makeBinaryFunc(">="))
+    buffer += BuiltinFunc("sle", makeBinaryFunc("<="))
+    buffer += BuiltinFunc("eq", makeBinaryFunc("==="))
     buffer += BuiltinFunc("unit", makeUnaryFunc("undefined"))
     buffer += BuiltinFunc(
       "log", fn(_, param("x")) { `return` { id("console.info")(id("x")) } }

shared/src/main/scala/mlscript/codegen/Scope.scala

@@ -47,6 +47,12 @@ class Scope(name: Str, enclosing: Opt[Scope]) {
       "div",
       "gt",
       "not",
+      "ne",
+      "eq",
+      "sgt",
+      "slt",
+      "sge",
+      "sle",
       "typeof",
       "toString",
       "negate",
@@ -69,11 +75,20 @@ class Scope(name: Str, enclosing: Opt[Scope]) {
     i <- (1 to Int.MaxValue).iterator
     c <- Scope.nameAlphabet.combinations(i)
     name = c.mkString
-    if !runtimeSymbols.contains(name)
+    if !hasRuntimeName(name)
   } yield {
     name
   }
 
+  /**
+    * Check if a runtime name is used recursively.
+    *
+    * @param name the name
+    * @return whether it's available or not
+    */
+  private def hasRuntimeName(name: Str): Bool =
+    runtimeSymbols.contains(name) || enclosing.exists(_.hasRuntimeName(name))
+
   /**
     * Allocate a non-sense runtime name.
     */

shared/src/main/scala/mlscript/helpers.scala

@@ -218,7 +218,7 @@ trait TypeImpl extends Located { self: Type =>
     case _: Union | _: Function | _: Tuple | _: Recursive
         | _: Neg | _: Rem | _: Bounds | _: WithExtension | Top | Bot
         | _: Literal | _: TypeVar | _: AppliedType | _: TypeName 
-        | _: Constrained | _ : Splice | _: TypeTag | _: PolyType =>
+        | _: Constrained | _ : Splice | _: TypeTag | _: PolyType | _: Selection =>
       Nil
   }
 
@@ -232,7 +232,8 @@ trait TypeImpl extends Located { self: Type =>
     case Inter(lhs, rhs) => lhs.collectTypeNames ++ rhs.collectTypeNames
     case _: Union | _: Function | _: Record | _: Tuple | _: Recursive
         | _: Neg | _: Rem | _: Bounds | _: WithExtension | Top | Bot | _: PolyType
-        | _: Literal | _: TypeVar | _: Constrained | _ : Splice | _: TypeTag =>
+        | _: Literal | _: TypeVar | _: Constrained | _ : Splice | _: TypeTag
+        | _: Selection =>
       Nil
   }
 
@@ -245,7 +246,8 @@ trait TypeImpl extends Located { self: Type =>
     case Inter(ty1, ty2) => ty1.collectBodyFieldsAndTypes ++ ty2.collectBodyFieldsAndTypes
     case _: Union | _: Function | _: Tuple | _: Recursive
         | _: Neg | _: Rem | _: Bounds | _: WithExtension | Top | Bot | _: PolyType
-        | _: Literal | _: TypeVar | _: AppliedType | _: TypeName | _: Constrained | _ : Splice | _: TypeTag =>
+        | _: Literal | _: TypeVar | _: AppliedType | _: TypeName | _: Constrained | _ : Splice | _: TypeTag
+        | _: Selection =>
       Nil
   }
 }
@@ -729,6 +731,8 @@ trait StatementImpl extends Located { self: Statement =>
         ).withLocOf(hd) :: cs)
     case NuTypeDef(Nms, nme, tps, tup @ Tup(fs), sig, pars, sup, ths, unit) =>
       ??? // TODO
+    case NuTypeDef(Mxn, nme, tps, tup @ Tup(fs), sig, pars, sup, ths, unit) =>
+      ??? // TODO
     case NuTypeDef(k @ Als, nme, tps, tup @ Tup(fs), sig, pars, sup, ths, unit) =>
       // TODO properly check:
       require(fs.isEmpty, fs)

shared/src/main/scala/mlscript/ucs/Clause.scala

@@ -9,64 +9,70 @@ import scala.collection.mutable.Buffer
   * A `Clause` represents a minimal unit of logical predicate in the UCS.
   * There are three kinds of clauses: boolean test, class match, and tuple match.
   */
-abstract class Clause {
+sealed abstract class Clause {
   /**
     * Local interleaved let bindings declared before this condition.
     */
-  var bindings: Ls[(Bool, Var, Term)] = Nil
+  var bindings: Ls[LetBinding] = Nil
 
   /**
     * Locations of terms that build this `Clause`.
     *
     * @return
     */
   val locations: Ls[Loc]
+
+  protected final def bindingsToString: String =
+    if (bindings.isEmpty) "" else " with " + (bindings match {
+      case Nil => ""
+      case bindings => bindings.map(_.name.name).mkString("(", ", ", ")")
+    })
+}
+
+sealed abstract class MatchClause extends Clause {
+  val scrutinee: Scrutinee
 }
 
 object Clause {
+  final case class MatchLiteral(
+    override val scrutinee: Scrutinee,
+    literal: SimpleTerm
+  )(override val locations: Ls[Loc]) extends MatchClause {
+    override def toString: String = s"«$scrutinee is $literal" + bindingsToString
+  }
+
+  final case class MatchAny(override val scrutinee: Scrutinee)(override val locations: Ls[Loc]) extends MatchClause {
+    override def toString: String = s"«$scrutinee is any" + bindingsToString
+  }
+
   final case class MatchClass(
-    scrutinee: Scrutinee,
+    override val scrutinee: Scrutinee,
     className: Var,
     fields: Ls[Str -> Var]
-  )(override val locations: Ls[Loc]) extends Clause
+  )(override val locations: Ls[Loc]) extends MatchClause {
+    override def toString: String = s"«$scrutinee is $className»" + bindingsToString
+  }
 
   final case class MatchTuple(
     scrutinee: Scrutinee,
     arity: Int,
     fields: Ls[Str -> Var]
-  )(override val locations: Ls[Loc]) extends Clause
-
-  final case class BooleanTest(test: Term)(override val locations: Ls[Loc]) extends Clause
-
-  def showBindings(bindings: Ls[(Bool, Var, Term)]): Str =
-    bindings match {
-      case Nil => ""
-      case bindings => bindings.map {
-        case (_, Var(name), _) => name
-      }.mkString("(", ", ", ")")
-    }
-
+  )(override val locations: Ls[Loc]) extends Clause {
+    override def toString: String = s"«$scrutinee is Tuple#$arity»" + bindingsToString
+  }
 
-  def showClauses(clauses: Iterable[Clause]): Str = {
-    clauses.iterator.map { clause =>
-      (clause match {
-        case Clause.BooleanTest(test) => s"«$test»"
-        case Clause.MatchClass(scrutinee, Var(className), fields) =>
-          s"«$scrutinee is $className»"
-        case Clause.MatchTuple(scrutinee, arity, fields) =>
-          s"«$scrutinee is Tuple#$arity»"
-      }) + (if (clause.bindings.isEmpty) "" else " with " + showBindings(clause.bindings))
-    }.mkString("", " and ", "")
+  final case class BooleanTest(test: Term)(
+    override val locations: Ls[Loc]
+  ) extends Clause {
+    override def toString: String = s"«$test»" + bindingsToString
   }
 
-  def print(println: (=> Any) => Unit, conjunctions: Iterable[Conjunction -> Term]): Unit = {
-    println("Flattened conjunctions")
-    conjunctions.foreach { case Conjunction(clauses, trailingBindings) -> term =>
-      println("+ " + showClauses(clauses) + {
-        (if (trailingBindings.isEmpty) "" else " ") +
-          showBindings(trailingBindings) +
-          s" => $term"
-      })
-    }
+  /**
+    * @param isField whether this binding is extracting a class field
+    */
+  final case class Binding(name: Var, term: Term, isField: Bool)(
+    override val locations: Ls[Loc]
+  ) extends Clause {
+    override def toString: String = s"«$name = $term»" + bindingsToString
   }
 }