Ultimate conditional syntax

compiler/shared/test/diff/Lifter.mls

@@ -151,16 +151,16 @@ class A<T, U>(x: Int): {a1: Int} & B<T> & D(x){
   }
 }
 //│ |#class| |B|‹|T|›| |{||}|↵|#class| |C| |{||}|↵|#class| |D|(|y|#:| |Int|)| |{||}|↵|#class| |A|‹|T|,| |U|›|(|x|#:| |Int|)|#:| |{|a1|#:| |Int|}| |&| |B|‹|T|›| |&| |D|(|x|)|{|→|#fun| |getA|(||)| |#=| |#new| |C|{|→|#fun| |foo|(|x|#:| |T|)| |#=| |x|←|↵|}|←|↵|}|
-//│ Parsed: {class B‹T›() {}; class C() {}; class D(y: Int,) {}; class A‹T, U›(x: Int,): & ('{' {a1: Int} '}',) (& (B‹T›,) (D (x,),),) {fun getA =  => new C() {fun foo = x: T, => x}}}
+//│ Parsed: {class B‹T›() {}; class C() {}; class D(y: Int,) {}; class A‹T, U›(x: Int,): & (& ('{' {a1: Int} '}',) (B‹T›,),) (D (x,),) {fun getA =  => new C() {fun foo = x: T, => x}}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, B, (TypeName(T)), Tup(), (), TypingUnit()), NuTypeDef(class, C, (), Tup(), (), TypingUnit()), NuTypeDef(class, D, (), Tup(y: Var(Int)), (), TypingUnit()), NuTypeDef(class, A, (TypeName(T), TypeName(U)), Tup(x: Var(Int)), (App(App(Var(&), Tup(_: Bra(rcd = true, Rcd(Var(a1) = Var(Int))))), Tup(_: App(App(Var(&), Tup(_: TyApp(Var(B), List(TypeName(T))))), Tup(_: App(Var(D), Tup(_: Var(x)))))))), TypingUnit(NuFunDef(None, getA, [], Lam(Tup(), New(Some((TypeName(C),)), TypingUnit(List(fun foo = x: T, => x))))))))
+//│ TypingUnit(NuTypeDef(class, B, (TypeName(T)), Tup(), (), TypingUnit()), NuTypeDef(class, C, (), Tup(), (), TypingUnit()), NuTypeDef(class, D, (), Tup(y: Var(Int)), (), TypingUnit()), NuTypeDef(class, A, (TypeName(T), TypeName(U)), Tup(x: Var(Int)), (App(App(Var(&), Tup(_: App(App(Var(&), Tup(_: Bra(rcd = true, Rcd(Var(a1) = Var(Int))))), Tup(_: TyApp(Var(B), List(TypeName(T))))))), Tup(_: App(Var(D), Tup(_: Var(x)))))), TypingUnit(NuFunDef(None, getA, [], Lam(Tup(), New(Some((TypeName(C),)), TypingUnit(List(fun foo = x: T, => x))))))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class B$1[T]() {}
 //│   class C$2() {}
 //│   class D$3(y: Int,) {}
 //│   class A$4_C$1$5[T](par$A$4,): C$2 () {fun foo = x: T, => x}
-//│   class A$4[T,U](x: Int,): & ('{' {a1: Int} '}',) (& (B$1 ()‹T›,) (D$3 ((this).x,),),) {fun getA =  => {new A$4_C$1$5(this,) {}}}
+//│   class A$4[T,U](x: Int,): & (& ('{' {a1: Int} '}',) (B$1 ()‹T›,),) (D$3 ((this).x,),) {fun getA =  => {new A$4_C$1$5(this,) {}}}
 //│ }
 // │ TypingUnit(NuTypeDef(class, B, (TypeName(T)), Tup(), (), TypingUnit()), NuTypeDef(class, C, (), Tup(), (), TypingUnit()), NuTypeDef(class, A, (TypeName(T), TypeName(U)), Tup(x: Var(Int)), (App(App(Var(&), Tup(_: Bra(rcd = true, Rcd(Var(a1) = Var(Int)})))), Tup(_: TyApp(Var(B), List(TypeName(T)))))), TypingUnit(NuFunDef(None, getA, [], Lam(Tup(), New(Some((TypeName(C),)), TypingUnit(List(fun foo = x: T, => x))))))))
 
@@ -269,7 +269,7 @@ new B{
 //│ |#class| |A| |{|→|#fun| |getA| |#=| |0|↵|#fun| |funcA| |#=| |10|←|↵|}|↵|#class| |B|#:| |A|{|→|#fun| |getA| |#=| |1|↵|#fun| |funcB| |#=| |11|←|↵|}|↵|#new| |A|↵|#new| |B|↵|#fun| |f|(|x|)| |#=| |#if| |x| |is| |A| |#then| |0| |#else| |1|↵|f|(|#new| |A|{|→|#fun| |getA| |#=| |2|←|↵|}|)|↵|#new| |B|{|→|#fun| |getA| |#=| |funcB|←|↵|}|
 //│ Parsed: {class A() {fun getA = 0; fun funcA = 10}; class B(): A {fun getA = 1; fun funcB = 11}; new A() {}; new B() {}; fun f = x, => if (is (x,) (A,)) then 0 else 1; f (new A() {fun getA = 2},); new B() {fun getA = funcB}}
 //│ Parsed:
-//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), TypingUnit(NuFunDef(None, getA, [], IntLit(0)), NuFunDef(None, funcA, [], IntLit(10)))), NuTypeDef(class, B, (), Tup(), (Var(A)), TypingUnit(NuFunDef(None, getA, [], IntLit(1)), NuFunDef(None, funcB, [], IntLit(11)))), New(Some((TypeName(A),)), TypingUnit(List())), New(Some((TypeName(B),)), TypingUnit(List())), NuFunDef(None, f, [], Lam(Tup(_: Var(x)), If((is (x,) (A,)) then 0, Some(IntLit(1))))), App(Var(f), Tup(_: New(Some((TypeName(A),)), TypingUnit(List(fun getA = 2))))), New(Some((TypeName(B),)), TypingUnit(List(fun getA = funcB))))
+//│ TypingUnit(NuTypeDef(class, A, (), Tup(), (), TypingUnit(NuFunDef(None, getA, [], IntLit(0)), NuFunDef(None, funcA, [], IntLit(10)))), NuTypeDef(class, B, (), Tup(), (Var(A)), TypingUnit(NuFunDef(None, getA, [], IntLit(1)), NuFunDef(None, funcB, [], IntLit(11)))), New(Some((TypeName(A),)), TypingUnit(List())), New(Some((TypeName(B),)), TypingUnit(List())), NuFunDef(None, f, [], Lam(Tup(_: Var(x)), If(IfThen(App(App(Var(is), Tup(_: Var(x))), Tup(_: Var(A))), IntLit(0), Some(IntLit(1))))), App(Var(f), Tup(_: New(Some((TypeName(A),)), TypingUnit(List(fun getA = 2))))), New(Some((TypeName(B),)), TypingUnit(List(fun getA = funcB))))
 //│ Lifted:
 //│ TypingUnit {
 //│   class A$1() {fun getA = 0; fun funcA = 10}

compiler/shared/test/diff/LifterBlks.mls

@@ -132,7 +132,7 @@ fun f(x,y,z) =
     fun boo = (new A).bar1 + B().bar2 + z
   }
 //│ |#fun| |f|(|x|,|y|,|z|)| |#=| |→|#class| |C|{|→|#class| |A|{|→|#fun| |foo| |#=| |#new| |B|↵|#fun| |bar1| |#=| |x|←|↵|}|↵|#class| |B|{|→|#fun| |foo| |#=| |#new| |A|↵|#fun| |bar2| |#=| |y|←|↵|}|↵|#fun| |boo| |#=| |(|#new| |A|)|.bar1| |+| |B|(||)|.bar2| |+| |z|←|↵|}|←|
-//│ Parsed: {fun f = x, y, z, => {class C() {class A() {fun foo = new B() {}; fun bar1 = x}; class B() {fun foo = new A() {}; fun bar2 = y}; fun boo = + (('(' new A() {}, ')').bar1,) (+ ((B ()).bar2,) (z,),)}}}
+//│ Parsed: {fun f = x, y, z, => {class C() {class A() {fun foo = new B() {}; fun bar1 = x}; class B() {fun foo = new A() {}; fun bar2 = y}; fun boo = + (+ (('(' new A() {}, ')').bar1,) ((B ()).bar2,),) (z,)}}}
 //│ Parsed:
 //│ TypingUnit(NuFunDef(None, f, [], Lam(Tup(_: Var(x), _: Var(y), _: Var(z)), Blk(...))))
 //│ Lifted:
@@ -146,7 +146,7 @@ fun f(x,y,z) =
 //│     fun bar2 = ((this).par$C$1).y
 //│   }
 //│   class C$1(x, y, z,) {
-//│     fun boo = + (('(' new C$1_A$2(this,) {}, ')').bar1,) (+ ((C$1_B$3 (this,)).bar2,) ((this).z,),)
+//│     fun boo = + (+ (('(' new C$1_A$2(this,) {}, ')').bar1,) ((C$1_B$3 (this,)).bar2,),) ((this).z,)
 //│   }
 //│   fun f = x, y, z, => {}
 //│ }

js/src/main/scala/Main.scala

@@ -311,7 +311,7 @@ object Main {
               subsume(ty_sch, sign)(ctx, raise, TypeProvenance(d.toLoc, "def definition"))
               // Note: keeping the less precise declared type signature here (no ctx update)
             case N =>
-              ctx += nme.name -> ty_sch
+              ctx += nme.name -> VarSymbol(ty_sch, nme)
           }
           res ++= formatBinding(d.nme.name, ty_sch)
           results append S(d.nme.name) -> htmlize(getType(ty_sch).show)
@@ -327,22 +327,22 @@ object Main {
           }
           val ty_sch = PolymorphicType(0, typeType(rhs)(ctx.nextLevel, raise,
             vars = tps.map(tp => tp.name -> freshVar(noProv/*FIXME*/)(1)).toMap))
-          ctx += nme.name -> ty_sch
+          ctx += nme.name -> VarSymbol(ty_sch, nme)
           declared += nme -> ty_sch
           results append S(d.nme.name) -> htmlize(getType(ty_sch).show)
         case s: DesugaredStatement =>
           typer.typeStatement(s, allowPure = true) match {
             case R(binds) =>
               binds.foreach { case (nme, pty) =>
-                ctx += nme -> pty
+                ctx += nme -> VarSymbol(pty, Var(nme))
                 res ++= formatBinding(nme, pty)
                 results append S(nme) -> htmlize(getType(pty).show)
               }
             case L(pty) =>
               val exp = getType(pty)
               if (exp =/= TypeName("unit")) {
                 val nme = "res"
-                ctx += nme -> pty
+                ctx += nme -> VarSymbol(pty, Var(nme))
                 res ++= formatBinding(nme, pty)
                 results append N -> htmlize(getType(pty).show)
               }

shared/src/main/scala/mlscript/JSBackend.scala

@@ -137,6 +137,7 @@ class JSBackend(allowUnresolvedSymbols: Boolean) {
     * Translate MLscript terms into JavaScript expressions.
     */
   protected def translateTerm(term: Term)(implicit scope: Scope): JSExpr = term match {
+    case _ if term.desugaredTerm.isDefined => translateTerm(term.desugaredTerm.get)
     case Var(name) => translateVar(name, false)
     case Lam(params, body) =>
       val lamScope = scope.derive("Lam")
@@ -178,15 +179,17 @@ class JSBackend(allowUnresolvedSymbols: Boolean) {
       )
     case Blk(stmts) =>
       val blkScope = scope.derive("Blk")
+      val flattened = stmts.iterator.flatMap(_.desugared._2).toList
       JSImmEvalFn(
         N,
         Nil,
-        R(blkScope.tempVars `with` (stmts flatMap (_.desugared._2) map {
-          case t: Term             => JSExprStmt(translateTerm(t))
+        R(blkScope.tempVars `with` (flattened.iterator.zipWithIndex.map {
+          case (t: Term, index) if index + 1 == flattened.length => translateTerm(t)(blkScope).`return`
+          case (t: Term, index)                                  => JSExprStmt(translateTerm(t)(blkScope))
           // TODO: find out if we need to support this.
-          case _: Def | _: TypeDef | _: NuFunDef /* | _: NuTypeDef */ =>
-            throw CodeGenError("unexpected definitions in blocks")
-        })),
+          case (_: Def | _: TypeDef | _: NuFunDef /* | _: NuTypeDef */, _) =>
+            throw CodeGenError("unsupported definitions in blocks")
+        }.toList)),
         Nil
       )
     // Pattern match with only one branch -> comma expression
@@ -235,7 +238,15 @@ class JSBackend(allowUnresolvedSymbols: Boolean) {
         case _ =>
           throw CodeGenError(s"illegal assignemnt left-hand side: ${inspect(lhs)}")
       }
-    case _: Bind | _: Test | If(_, _) | New(_, _) | TyApp(_, _) | _: Splc =>
+    case iff: If =>
+      throw CodeGenError(s"if expression has not been desugared")
+    case New(N, TypingUnit(Nil)) => JSRecord(Nil)
+    case New(S(TypeName(className) -> Tup(args)), TypingUnit(Nil)) =>
+      val callee = translateVar(className, true)
+      callee(args.map { case (_, Fld(_, _, arg)) => translateTerm(arg) }: _*)
+    case New(_, TypingUnit(_)) =>
+      throw CodeGenError("custom class body is not supported yet")
+    case _: Bind | _: Test | If(_, _) | TyApp(_, _) | _: Splc =>
       throw CodeGenError(s"cannot generate code for term ${inspect(term)}")
   }
 
@@ -629,22 +640,23 @@ class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
     // Generate statements.
     val queries = otherStmts.map {
       case Def(recursive, Var(name), L(body), isByname) =>
+        val bodyIsLam = body match { case _: Lam => true case _ => false }
         (if (recursive) {
           val isByvalueRecIn = if (isByname) None else Some(true)
-          val sym = scope.declareValue(name, isByvalueRecIn, body.isInstanceOf[Lam])
+          val sym = scope.declareValue(name, isByvalueRecIn, bodyIsLam)
           try {
             val translated = translateTerm(body)
             scope.unregisterSymbol(sym)
             val isByvalueRecOut = if (isByname) None else Some(false)
-            R((translated, scope.declareValue(name, isByvalueRecOut, body.isInstanceOf[Lam])))
+            R((translated, scope.declareValue(name, isByvalueRecOut, bodyIsLam)))
           } catch {
             case e: UnimplementedError =>
               scope.stubize(sym, e.symbol)
               L(e.getMessage())
             case e: Throwable =>
               scope.unregisterSymbol(sym)
               val isByvalueRecOut = if (isByname) None else Some(false)
-              scope.declareValue(name, isByvalueRecOut, body.isInstanceOf[Lam])
+              scope.declareValue(name, isByvalueRecOut, bodyIsLam)
               throw e
           }
         } else {
@@ -655,7 +667,7 @@ class JSTestBackend extends JSBackend(allowUnresolvedSymbols = false) {
             case e: Throwable => throw e
           }) map {
             val isByvalueRec = if (isByname) None else Some(false)
-            expr => (expr, scope.declareValue(name, isByvalueRec, body.isInstanceOf[Lam]))
+            expr => (expr, scope.declareValue(name, isByvalueRec, bodyIsLam))
           }
         }) match {
           case R((originalExpr, sym)) =>
@@ -736,7 +748,9 @@ object JSTestBackend {
   /**
     * Represents the result of code generation.
     */
-  abstract class Result
+  abstract class Result {
+    def showFirstResult(prefixLength: Int): Unit = ()
+  }
 
   /**
     * Emitted code.

shared/src/main/scala/mlscript/NewParser.scala

@@ -93,6 +93,7 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], raiseFun: D
       "",
       "",
       "",
+      "",
       // ^ for keywords
       ",",
       ";",
@@ -116,10 +117,11 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], raiseFun: D
 
   def opCharPrec(opChar: Char): Int = prec(opChar)
   def opPrec(opStr: Str): (Int, Int) = opStr match {
+    case "is" => (4, 4)
     case "and" => (3, 3)
     case "or" => (2, 2)
     case _ if opStr.exists(_.isLetter) =>
-      (4, 4)
+      (5, 5)
     case _ =>
       val r = opStr.last
       (prec(opStr.head), prec(r) - (if (r === '@' || r === '/' || r === ',') 1 else 0))
@@ -652,25 +654,26 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], raiseFun: D
           }
           case _ => ???
         })
-        exprCont(res, 0, allowNewlines)
+        exprCont(res, prec, allowNewlines)
 
       case (br @ BRACKETS(Square, toks), loc) :: _ =>
         consume
         val idx = rec(toks, S(br.innerLoc), "subscript").concludeWith(_.expr(0))
         val res = Subs(acc, idx.withLoc(S(loc)))
-        exprCont(res, 0, allowNewlines)
+        exprCont(res, prec, allowNewlines)
 
         case (br @ BRACKETS(Round, toks), loc) :: _ =>
           consume
           val as = rec(toks, S(br.innerLoc), br.describe).concludeWith(_.argsMaybeIndented())
           val res = App(acc, Tup(as).withLoc(S(loc)))
-          exprCont(res, 0, allowNewlines)
+          exprCont(res, prec, allowNewlines)
+
         case (KEYWORD("of"), _) :: _ =>
           consume
           val as = argsMaybeIndented()
           // val as = argsOrIf(Nil) // TODO
           val res = App(acc, Tup(as))
-          exprCont(res, 0, allowNewlines)
+          exprCont(res, prec, allowNewlines)
 
       case c @ (h :: _) if (h._1 match {
         case KEYWORD(";" | "of") | BRACKETS(Round | Square, _)
@@ -686,7 +689,7 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], raiseFun: D
         val res = App(acc, Tup(as))
         raise(WarningReport(msg"Paren-less applications should use the 'of' keyword"
           -> res.toLoc :: Nil))
-        exprCont(res, 0, allowNewlines)
+        exprCont(res, prec, allowNewlines)
 
       case _ => R(acc)
     }

shared/src/main/scala/mlscript/TypeDefs.scala

@@ -181,7 +181,7 @@ class TypeDefs extends NuTypeDefs { self: Typer =>
           val (bodyTy, tvars) = 
             typeType2(td.body, simplify = false)(ctx.copy(lvl = 0), raise, tparamsargs.map(_.name -> _).toMap, newDefsInfo)
           val td1 = TypeDef(td.kind, td.nme, tparamsargs.toList, tvars, bodyTy,
-            td.mthDecls, td.mthDefs, baseClassesOf(td), td.toLoc, Nil)
+            td.mthDecls, td.mthDefs, baseClassesOf(td), td.toLoc, td.positionals.map(_.name))
           allDefs += n -> td1
           S(td1)
       }
@@ -337,7 +337,7 @@ class TypeDefs extends NuTypeDefs { self: Typer =>
                         singleTup(tv), tv & nomTag & RecordType.mk(tparamTags)(noProv)
                       )(originProv(td.nme.toLoc, "trait constructor", td.nme.name)))
                   }
-                  ctx += n.name -> ctor
+                  ctx += n.name -> VarSymbol(ctor, Var(n.name))
               }
               true
             }
@@ -491,7 +491,7 @@ class TypeDefs extends NuTypeDefs { self: Typer =>
           def go(md: MethodDef[_ <: Term \/ Type]): (Str, MethodType) = {
             val thisTag = TraitTag(Var("this"))(noProv)
             val thisTy = thisTag & tr
-            thisCtx += "this" -> thisTy
+            thisCtx += "this" -> VarSymbol(thisTy, Var("this"))
             val MethodDef(rec, prt, nme, tparams, rhs) = md
             val prov: TypeProvenance = tp(md.toLoc,
               (if (!top) "inherited " else "")