Export TypeScript Declarations in New Syntax

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

@@ -459,6 +459,7 @@ class JSBackend {
         traits += topLevelScope.declareTrait(name, tparams map { _.name }, body, methods)
       case TypeDef(Cls, TypeName(name), tparams, baseType, _, members, _) =>
         classes += topLevelScope.declareClass(name, tparams map { _.name }, baseType, members)
+      case TypeDef(Nms, TypeName(name), _, _, _, members, _) => () // TODO: deal with namespace
     }
     (traits.toList, classes.toList)
   }

shared/src/main/scala/mlscript/MLParser.scala

@@ -204,6 +204,7 @@ class MLParser(origin: Origin, indent: Int = 0, recordLocations: Bool = true) {
           ms.collect { case R(md) => md }, ms.collect{ case L(md) => md }, Nil)
       }
       case (k @ Als, id, ts) => "=" ~ ty map (bod => TypeDef(k, id, ts, bod, Nil, Nil, Nil))
+      case (k @ Nms, id, _) => "=" ~ ty map (bod => TypeDef(k, id, Nil, bod, Nil, Nil, Nil)) // TODO: deal with namespaces
     })
   def tyParams[p: P]: P[Ls[TypeName]] =
     ("[" ~ tyName.rep(0, ",") ~ "]").?.map(_.toList.flatten)

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

@@ -84,6 +84,16 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
         val (txt, k) =
           takeWhile(j)(c => c =/= '\n')
         go(k, COMMENT(txt))
+      case '/' if bytes.lift(i + 1).contains('*') =>
+        val j = i + 2
+        var prev1 = '/'; var prev2 = '*'
+        val (txt, k) =
+          takeWhile(j)(c => {
+            val r = prev1 =/= '*' || prev2 =/= '/'
+            prev1 = prev2; prev2 = c
+            r
+          })
+        go(k, COMMENT(txt.dropRight(2)))
       case BracketKind(Left(k)) => go(i + 1, OPEN_BRACKET(k))
       case BracketKind(Right(k)) => go(i + 1, CLOSE_BRACKET(k))
       case '\n' =>
@@ -119,6 +129,8 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
           val (name, k) = takeWhile(j)(isIdentChar)
           go(k, SELECT(name))
         }
+        else if (c === '>' && n.length > 1 && n.foldLeft(true)((r, i) => r && (i === c)))
+          go(i + 1, IDENT(">", true))
         else go(j, if (isSymKeyword.contains(n)) KEYWORD(n) else IDENT(n, true))
       case _ if isDigit(c) =>
         val (str, j) = takeWhile(i)(isDigit)
@@ -164,7 +176,7 @@ class NewLexer(origin: Origin, raise: Diagnostic => Unit, dbg: Bool) {
               if (k0 =/= k1)
                 raise(ErrorReport(msg"Mistmatched closing ${k1.name}" -> S(l1) ::
                   msg"does not correspond to opening ${k0.name}" -> S(l0) :: Nil, source = Parsing))
-              go(rest, false, stack, BRACKETS(k0, acc.reverse)(l0.right ++ l1.left) -> (l0 ++ l1) :: oldAcc)
+              go(rest, true, stack, BRACKETS(k0, acc.reverse)(l0.right ++ l1.left) -> (l0 ++ l1) :: oldAcc)
             case Nil =>
               raise(ErrorReport(msg"Unexpected closing ${k1.name}" -> S(l1) :: Nil, source = Parsing))
               go(rest, false, stack, acc)
@@ -234,6 +246,7 @@ object NewLexer {
     "trait",
     "interface",
     "new",
+    "namespace"
   )
 
   def printToken(tl: TokLoc): Str = tl match {

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

@@ -137,7 +137,10 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], raiseFun: D
 
   private def cur(implicit l: Line, n: Name) = {
     if (dbg) printDbg(s"? ${n.value}\t\tinspects ${summarizeCur}    [at l.${l.value}]")
-    _cur
+    _cur.dropWhile(_._1 match {
+      case COMMENT(_) => true
+      case _ => false
+    })
   }
 
   def consume(implicit l: Line, n: Name): Unit = {
@@ -235,12 +238,13 @@ abstract class NewParser(origin: Origin, tokens: Ls[Stroken -> Loc], raiseFun: D
       case (SPACE, _) :: _ => consume; block
       case c =>
         val t = c match {
-          case (KEYWORD(k @ ("class" | "trait" | "type")), l0) :: c =>
+          case (KEYWORD(k @ ("class" | "trait" | "type" | "namespace")), l0) :: c =>
             consume
             val kind = k match {
               case "class" => Cls
               case "trait" => Trt
               case "type" => Als
+              case "namespace" => Nms
               case _ => die
             }
             val (tn, success) = yeetSpaces match {

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

@@ -227,6 +227,7 @@ class TypeDefs extends NuTypeDefs { self: Typer =>
 
         val rightParents = td.kind match {
           case Als => checkCycle(td.bodyTy)(Set.single(L(td.nme)))
+          case Nms => checkCycle(td.bodyTy)(Set.single(L(td.nme)))
           case k: ObjDefKind =>
             val parentsClasses = MutSet.empty[TypeRef]
             def checkParents(ty: SimpleType): Bool = ty match {
@@ -246,6 +247,9 @@ class TypeDefs extends NuTypeDefs { self: Typer =>
                     } else
                       checkParents(tr.expand)
                   case Trt => checkParents(tr.expand)
+                  case Nms =>
+                    err(msg"cannot inherit from a namespace", prov.loco)
+                    false
                   case Als => 
                     err(msg"cannot inherit from a type alias", prov.loco)
                     false

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

@@ -307,6 +307,8 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool)
                   case Trt => trtNameToNomTag(td)(tyTp(tyLoc, "trait tag"), ctx)
                   case Als => err(
                     msg"Type alias ${name.capitalize} cannot be used as a type tag", tyLoc)(raise)
+                  case Nms => err(
+                    msg"Namespaces ${name.capitalize} cannot be used as a type tag", tyLoc)(raise)
                 }
                 case _ => e()
               }
@@ -750,6 +752,7 @@ class Typer(var dbg: Boolean, var verbose: Bool, var explainErrors: Bool)
             case Some(td) =>
               td.kind match {
                 case Als => err(msg"can only match on classes and traits", pat.toLoc)(raise)
+                case Nms => err(msg"can only match on classes and traits", pat.toLoc)(raise)
                 case Cls => clsNameToNomTag(td)(tp(pat.toLoc, "class pattern"), ctx)
                 case Trt => trtNameToNomTag(td)(tp(pat.toLoc, "trait pattern"), ctx)
               }

shared/src/main/scala/mlscript/TyperDatatypes.scala

@@ -234,6 +234,7 @@ abstract class TyperDatatypes extends TyperHelpers { self: Typer =>
         else TopType
       subst(td.kind match {
         case Als => td.bodyTy
+        case Nms => td.bodyTy // TODO: deal with namespaces
         case Cls => clsNameToNomTag(td)(prov, ctx) & td.bodyTy & tparamTags
         case Trt => trtNameToNomTag(td)(prov, ctx) & td.bodyTy & tparamTags
       }, td.targs.lazyZip(targs).toMap) //.withProv(prov)

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

@@ -4,7 +4,7 @@ import mlscript.utils.shorthands._
 import mlscript.{JSStmt, JSExpr, JSLetDecl}
 import mlscript.Type
 import scala.reflect.ClassTag
-import mlscript.{TypeName, Top, Bot, TypeDef, Als, Trt, Cls}
+import mlscript.{TypeName, Top, Bot, TypeDef, Als, Trt, Cls, Nms}
 import mlscript.MethodDef
 import mlscript.Term
 import mlscript.utils.{AnyOps, lastWords}
@@ -200,6 +200,8 @@ class Scope(name: Str, enclosing: Opt[Scope]) {
       declareTrait(name, tparams map { _.name }, body, mthdDefs)
     case TypeDef(Cls, TypeName(name), tparams, baseType, _, members, _) =>
       declareClass(name, tparams map { _.name }, baseType, members)
+    case TypeDef(Nms, TypeName(name), _, body, _, _, _) =>
+      declareTypeAlias(name, Ls(), body) // TODO: deal with namespaces
   }
 
   def declareClass(

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

@@ -428,10 +428,15 @@ trait TermImpl extends StatementImpl { self: Term =>
     case Tup(fields) => Tuple(fields.map(fld => (fld._1, fld._2 match {
       case Fld(m, s, v) => val ty = v.toType_!; Field(Option.when(m)(ty), ty)
     })))
+    case Bra(rcd, trm) if (!rcd) => trm.toType_!
+    case TyApp(lhs, targs) => lhs.toType_! match {
+      case p: TypeName => AppliedType(p, targs)
+      case _ => throw new NotAType(this)
+    }
     // TODO:
     // case Rcd(fields) => ???
     // case Sel(receiver, fieldName) => ???
-    // case Let(isRec, name, rhs, body) => ???
+    // case Let(isRec, name, rhs, body) => 
     // case Blk(stmts) => ???
     // case Bra(rcd, trm) => ???
     // case Asc(trm, ty) => ???

shared/src/main/scala/mlscript/syntax.scala

@@ -48,6 +48,7 @@ sealed trait ObjDefKind
 case object Cls extends TypeDefKind("class") with ObjDefKind
 case object Trt extends TypeDefKind("trait") with ObjDefKind
 case object Als extends TypeDefKind("type alias")
+case object Nms extends TypeDefKind("namespace")
 
 sealed abstract class Term                                           extends Terms with TermImpl
 sealed abstract class Lit                                            extends SimpleTerm with LitImpl

shared/src/test/diff/parser/Comments.mls

@@ -2,14 +2,8 @@
 // TODO comments
 1 // whoops
 //│ |1| |/* whoops*/|
-//│ ╔══[PARSE ERROR] Unexpected comment in expression position
-//│ ║  l.3: 	1 // whoops
-//│ ╙──     	  ^^^^^^^^^
-//│ ╔══[PARSE ERROR] Unexpected end of input; an expression was expected here
-//│ ║  l.3: 	1 // whoops
-//│ ╙──     	           ^
-//│ ╔══[WARNING] Paren-less applications should use the 'of' keyword
-//│ ║  l.3: 	1 // whoops
-//│ ╙──     	^^^^^^^^^^^
-//│ Parsed: {1 (undefined,)}
+//│ Parsed: {1}
 
+2 /* whoops */
+//│ |2| |/* whoops */|
+//│ Parsed: {2}

ts2mls/js/src/main/scala/ts2mls/JSWriter.scala

@@ -11,6 +11,8 @@ class JSWriter(filename: String) {
   private var fileSize = 0 // how many bytes we've written in the file
   private var needTruncate = false
 
+  writeln(":NewParser\n:ParseOnly")
+
   def writeln(str: String) = {
     val strln = str + "\n"
     val buffer = createBuffer(strln.length)

ts2mls/js/src/main/scala/ts2mls/TSNamespace.scala

@@ -2,6 +2,7 @@ package ts2mls
 
 import scala.collection.mutable.{HashMap, ListBuffer}
 import types._
+import mlscript.utils._
 
 class TSNamespace(name: String, parent: Option[TSNamespace]) {
   private val subSpace = HashMap[String, TSNamespace]()
@@ -34,40 +35,51 @@ class TSNamespace(name: String, parent: Option[TSNamespace]) {
   def containsMember(name: String, searchParent: Boolean = true): Boolean =
     if (parent.isEmpty) members.contains(name) else (members.contains(name) || (searchParent && parent.get.containsMember(name)))
 
-  def generate(writer: JSWriter): Unit =
+  def generate(writer: JSWriter, indent: String): Unit =
     order.toList.foreach((p) => p match {
-      case Left(name) => subSpace(name).generate(writer)
+      case Left(subName) => {
+        writer.writeln(s"${indent}namespace $subName {")
+        subSpace(subName).generate(writer, indent + "  ")
+        writer.writeln(s"$indent}")
+      }
       case Right(name) => {
         val mem = members(name)
-        val fullName = getFullPath(name)
+        // val fullName = getFullPath(name)
         mem match {
           case inter: TSIntersectionType => // overloaded functions
-            writer.writeln(s"def ${fullName}: ${Converter.convert(inter)}")
-          case f: TSFunctionType => {
-            val typeParams = f.typeVars.map((t) => t.name)
-            if (typeParams.isEmpty)
-              writer.writeln(s"def ${fullName}: ${Converter.convert(f)}")
-            else // TODO: add constraints
-              writer.writeln(s"def ${fullName}[${typeParams.reduceLeft((r, s) => s"$r, $s")}]: ${Converter.convert(f)}")
-          }
-          case overload @ TSIgnoredOverload(base, _) => {
-            val typeParams = base.typeVars.map((t) => t.name)
-              if (typeParams.isEmpty)
-                writer.writeln(s"def ${fullName}: ${Converter.convert(overload)}")
-              else // TODO: add constraints
-                writer.writeln(s"def ${fullName}[${typeParams.reduceLeft((r, s) => s"$r, $s")}]: ${Converter.convert(overload)}")
-          }
-          case _ => writer.writeln(Converter.convert(mem))
+            writer.writeln(s"${indent}let ${name}: ${Converter.convert(inter)}")
+          case f: TSFunctionType =>
+            writer.writeln(s"${indent}let ${name}: ${Converter.convert(f)}")
+          // {
+          //   val typeParams = f.typeVars.map((t) => t.name)
+          //   if (typeParams.isEmpty)
+          //     writer.writeln(s"def ${fullName}: ${Converter.convert(f)}")
+          //   else // TODO: add constraints
+          //     writer.writeln(s"def ${fullName}[${typeParams.reduceLeft((r, s) => s"$r, $s")}]: ${Converter.convert(f)}")
+          // }
+          case overload @ TSIgnoredOverload(base, _) =>
+            writer.writeln(s"${indent}let ${name}: ${Converter.convert(overload)}")
+          // {
+          //   val typeParams = base.typeVars.map((t) => t.name)
+          //     if (typeParams.isEmpty)
+          //       writer.writeln(s"def ${fullName}: ${Converter.convert(overload)}")
+          //     else // TODO: add constraints
+          //       writer.writeln(s"def ${fullName}[${typeParams.reduceLeft((r, s) => s"$r, $s")}]: ${Converter.convert(overload)}")
+          // }
+          case _: TSClassType => writer.writeln(indent + Converter.convert(mem)(indent))
+          case _ @ TSInterfaceType(name, _, _, _) if (name =/= "") =>
+            writer.writeln(indent + Converter.convert(mem)(indent))
+          case _ => writer.writeln(indent + Converter.convert(mem))
         }
       }
     })
 
   // generate full path with namespaces' names
   // e.g. f => Namespace1.Namespace2.f
-  def getFullPath(nm: String): String = parent match {
-    case Some(p) => p.getFullPath(s"$name'$nm")
-    case _ => nm
-  }
+  // def getFullPath(nm: String): String = parent match {
+  //   case Some(p) => p.getFullPath(s"$name'$nm")
+  //   case _ => nm
+  // }
 }
 
 object TSNamespace {

ts2mls/js/src/main/scala/ts2mls/TSProgram.scala

@@ -15,7 +15,7 @@ class TSProgram(filenames: Seq[String]) {
   implicit val checker = TSTypeChecker(program.getTypeChecker())
   filenames.foreach(filename => TSSourceFile(program.getSourceFile(filename), globalNamespace))
 
-  def generate(writer: JSWriter): Unit = globalNamespace.generate(writer)
+  def generate(writer: JSWriter): Unit = globalNamespace.generate(writer, "")
 }
 
 object TSProgram {

ts2mls/js/src/main/scala/ts2mls/TSSourceFile.scala

@@ -163,9 +163,9 @@ object TSSourceFile {
       }
     }
     else if (node.isClassDeclaration)
-      ns.put(name, parseMembers(ns.getFullPath(name), node, true))
+      ns.put(name, parseMembers(name, node, true))
     else if (node.isInterfaceDeclaration)
-      ns.put(name, parseMembers(ns.getFullPath(name), node, false))
+      ns.put(name, parseMembers(name, node, false))
     else if (node.isNamespace)
       parseNamespace(node)