Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Add readonly and const Parsing in ts2mls #153

Closed
wants to merge 11 commits into from
Closed

Add readonly and const Parsing in ts2mls #153

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
11 commits
Select commit Hold shift + click to select a range
b6f76f5
Add readonly
NeilKleistGao Nov 24, 2022
d8bb3eb
Add const variables parsing
NeilKleistGao Nov 28, 2022
ff79bd4
Merge branch 'mlscript' into mut
NeilKleistGao Nov 28, 2022
fbe22ef
Add mut for record fields
NeilKleistGao Nov 28, 2022
aec290e
Add mutable type
NeilKleistGao Nov 28, 2022
214398f
Add mut for variables in namespaces
NeilKleistGao Nov 28, 2022
7c33b91
Merge branch 'mlscript' into mut
NeilKleistGao Dec 1, 2022
3f9d90d
Apply new mut syntax
NeilKleistGao Dec 1, 2022
8679221
Use ascribe instead
NeilKleistGao Dec 1, 2022
2256675
Use unfinished syntax instead
NeilKleistGao Dec 1, 2022
cb86330
Merge branch 'mlscript' into mut
NeilKleistGao Dec 12, 2022
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 8 additions & 0 deletions ts2mls/js/src/main/scala/ts2mls/TSCompilerInfo.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,6 +21,8 @@ object TypeScript {
val syntaxKindPrivate = ts.SyntaxKind.PrivateKeyword
val syntaxKindProtected = ts.SyntaxKind.ProtectedKeyword
val syntaxKindStatic = ts.SyntaxKind.StaticKeyword
val syntaxKindReadonly = ts.SyntaxKind.ReadonlyKeyword // this flag is only for readonly members
val nodeFlagsConst = ts.NodeFlags.Const // this flag is for const variables
val objectFlagsAnonymous = ts.ObjectFlags.Anonymous
val symbolFlagsOptional = ts.SymbolFlags.Optional // this flag is only for checking optional members of interfaces

Expand Down Expand Up @@ -89,6 +91,7 @@ object TSSymbolObject {

class TSNodeObject(node: js.Dynamic)(implicit checker: TSTypeChecker) extends TSAny(node) {
private lazy val modifiers = TSTokenArray(node.modifiers)
private lazy val flags = node.flags

lazy val isToken = TypeScript.isToken(node)
lazy val isClassDeclaration = TypeScript.isClassDeclaration(node)
Expand Down Expand Up @@ -132,6 +135,9 @@ class TSNodeObject(node: js.Dynamic)(implicit checker: TSTypeChecker) extends TS
if (modifiers.isUndefined) Public
else modifiers.foldLeft[TSAccessModifier](Public)(
(m, t) => if (t.isPrivate) Private else if (t.isProtected) Protected else m)
lazy val readonly: Boolean =
if (modifiers.isUndefined) (flags & TypeScript.nodeFlagsConst > 0)
else modifiers.foldLeft[Boolean](false)((m, t) => m || t.isReadonly)

lazy val declarationList = TSNodeObject(node.declarationList)
lazy val declarations = TSNodeArray(node.declarations)
Expand All @@ -146,6 +152,7 @@ class TSNodeObject(node: js.Dynamic)(implicit checker: TSTypeChecker) extends TS
lazy val symbolType = TSTypeObject(checker.getTypeOfSymbolAtLocation(node.symbol, node))
lazy val literal = TSTokenObject(node.literal)
lazy val name = TSIdentifierObject(node.name)
lazy val parent = TSNodeObject(node.parent)
}

object TSNodeObject {
Expand All @@ -158,6 +165,7 @@ class TSTokenObject(token: js.Dynamic)(implicit checker: TSTypeChecker) extends
lazy val isPrivate = kind == TypeScript.syntaxKindPrivate
lazy val isProtected = kind == TypeScript.syntaxKindProtected
lazy val isStatic = kind == TypeScript.syntaxKindStatic
lazy val isReadonly = kind == TypeScript.syntaxKindReadonly

lazy val typeNode = TSTypeObject(checker.getTypeFromTypeNode(token))
lazy val text = token.text.toString()
Expand Down
24 changes: 13 additions & 11 deletions ts2mls/js/src/main/scala/ts2mls/TSNamespace.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@ import mlscript.utils._

class TSNamespace(name: String, parent: Option[TSNamespace]) {
private val subSpace = HashMap[String, TSNamespace]()
private val members = HashMap[String, TSType]()
private val members = HashMap[String, (TSType, Boolean)]() // readonly: Boolean

// write down the order of members
// easier to check the output one by one
Expand All @@ -21,15 +21,15 @@ class TSNamespace(name: String, parent: Option[TSNamespace]) {
sub
}

def put(name: String, tp: TSType): Unit =
def put(name: String, tp: TSType, readonly: Boolean): Unit =
if (!members.contains(name)) {
order += Right(name)
members.put(name, tp)
members.put(name, (tp, readonly))
}
else members.update(name, tp)
else members.update(name, (tp, readonly))

def get(name: String): TSType =
members.getOrElse(name,
def get(name: String): (TSType, Boolean) =
members.getOrElse[(TSType, Boolean)](name,
if (!parent.isEmpty) parent.get.get(name) else throw new Exception(s"member $name not found."))

def containsMember(name: String, searchParent: Boolean = true): Boolean =
Expand All @@ -44,18 +44,20 @@ class TSNamespace(name: String, parent: Option[TSNamespace]) {
}
case Right(name) => {
val mem = members(name)
mem match {
mem._1 match {
case inter: TSIntersectionType => // overloaded functions
writer.writeln(Converter.generateFunDeclaration(inter, name)(indent))
case f: TSFunctionType =>
writer.writeln(Converter.generateFunDeclaration(f, name)(indent))
case overload: TSIgnoredOverload =>
writer.writeln(Converter.generateFunDeclaration(overload, name)(indent))
case _: TSClassType => writer.writeln(Converter.convert(mem)(indent))
case _: TSClassType => writer.writeln(Converter.convert(mem._1)(indent))
case TSInterfaceType(name, _, _, _) if (name =/= "") =>
writer.writeln(Converter.convert(mem)(indent))
case _: TSTypeAlias => writer.writeln(Converter.convert(mem)(indent))
case _ => writer.writeln(s"${indent}let $name: ${Converter.convert(mem)("")}")
writer.writeln(Converter.convert(mem._1)(indent))
case _: TSTypeAlias => writer.writeln(Converter.convert(mem._1)(indent))
case _ =>
if (mem._2) writer.writeln(s"${indent}let $name: ${Converter.convert(mem._1)("")}")
else writer.writeln(s"${indent}let $name: {mut contents: ${Converter.convert(mem._1)("")}}")
}
}
})
Expand Down
31 changes: 18 additions & 13 deletions ts2mls/js/src/main/scala/ts2mls/TSSourceFile.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -110,7 +110,7 @@ object TSSourceFile {

mem match {
case func: TSFunctionType => {
if (!mp.contains(name)) mp ++ Map(name -> TSMemberType(func, p.modifier))
if (!mp.contains(name)) mp ++ Map(name -> TSMemberType(func, p.modifier, !p.readonly))
else { // deal with functions overloading
val old = mp(name)
val res = old.base match {
Expand All @@ -126,10 +126,10 @@ object TSSourceFile {
case _ => old.base
}

mp.removed(name) ++ Map(name -> TSMemberType(res, p.modifier))
mp.removed(name) ++ Map(name -> TSMemberType(res, p.modifier, !p.readonly))
}
}
case _ => mp ++ Map(name -> TSMemberType(mem, p.modifier))
case _ => mp ++ Map(name -> TSMemberType(mem, p.modifier, !p.readonly))
}
}
else mp
Expand All @@ -145,11 +145,16 @@ object TSSourceFile {
})

private def getInterfacePropertiesType(list: TSNodeArray): Map[String, TSMemberType] =
list.foldLeft(Map[String, TSMemberType]())((mp, p) => mp ++ Map(p.symbol.escapedName -> TSMemberType(getMemberType(p))))
list.foldLeft(Map[String, TSMemberType]())((mp, p) =>
mp ++ Map(p.symbol.escapedName -> TSMemberType(getMemberType(p), Public, !p.readonly)))

private def getAnonymousPropertiesType(list: TSSymbolArray): Map[String, TSMemberType] =
list.foldLeft(Map[String, TSMemberType]())((mp, p) =>
mp ++ Map(p.escapedName -> TSMemberType(if (p.`type`.isUndefined) getMemberType(p.declaration) else getObjectType(p.`type`))))
mp ++ Map(p.escapedName -> TSMemberType(
(if (p.`type`.isUndefined) getMemberType(p.declaration) else getObjectType(p.`type`)),
Public, !p.declaration.readonly
)
))

private def parseMembers(name: String, node: TSNodeObject, isClass: Boolean): TSType =
if (isClass)
Expand All @@ -165,9 +170,9 @@ object TSSourceFile {
})

private def addFunctionIntoNamespace(fun: TSFunctionType, node: TSNodeObject, name: String)(implicit ns: TSNamespace) =
if (!ns.containsMember(name, false)) ns.put(name, fun)
if (!ns.containsMember(name, false)) ns.put(name, fun, true)
else {
val old = ns.get(name)
val old = ns.get(name)._1
val res = old match {
case f @ TSFunctionType(_, _, tv) =>
if (!tv.isEmpty || !fun.typeVars.isEmpty) TSIgnoredOverload(fun, name)
Expand All @@ -181,7 +186,7 @@ object TSSourceFile {
case _ => old
}

ns.put(name, res)
ns.put(name, res, true)
}

// overload functions in a sub-namespace need to provide an overload array
Expand All @@ -197,15 +202,15 @@ object TSSourceFile {
}
}
else if (node.isClassDeclaration)
ns.put(name, parseMembers(name, node, true))
ns.put(name, parseMembers(name, node, true), true)
else if (node.isInterfaceDeclaration)
ns.put(name, parseMembers(name, node, false))
ns.put(name, parseMembers(name, node, false), true)
else if (node.isTypeAliasDeclaration)
ns.put(name, TSTypeAlias(name, getTypeAlias(node.`type`), getTypeParameters(node)))
ns.put(name, TSTypeAlias(name, getTypeAlias(node.`type`), getTypeParameters(node)), true)
else if (node.isObjectLiteral)
ns.put(name, TSInterfaceType("", getObjectLiteralMembers(node.initializer.properties), List(), List()))
ns.put(name, TSInterfaceType("", getObjectLiteralMembers(node.initializer.properties), List(), List()), true)
else if (node.isVariableDeclaration)
ns.put(name, getMemberType(node))
ns.put(name, getMemberType(node), node.parent.readonly)
else if (node.isNamespace)
parseNamespace(node)

Expand Down
6 changes: 4 additions & 2 deletions ts2mls/js/src/main/scala/ts2mls/types/Converter.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -42,7 +42,7 @@ object Converter {
case TSTupleType(lst) => s"(${lst.foldLeft("")((p, t) => s"$p${convert(t)}, ")})"
case TSArrayType(element) => s"MutArray<${convert(element)}>"
case TSEnumType => "int"
case TSMemberType(base, _) => convert(base) // TODO: support private/protected members
case TSMemberType(base, _, _) => convert(base) // TODO: support private/protected members
case TSInterfaceType(name, members, typeVars, parents) =>
convertRecord(s"trait $name", members, typeVars, parents, Map(), List())(indent)
case TSClassType(name, members, statics, typeVars, parents, cons) =>
Expand All @@ -64,7 +64,9 @@ object Converter {
else m._2.base match {
case _: TSFunctionType => s"${generateFunDeclaration(m._2.base, m._1)(indent + " ")}\n"
case _: TSIgnoredOverload => s"${generateFunDeclaration(m._2.base, m._1)(indent + " ")}\n"
case _ => s"${indent} let ${m._1}: ${convert(m._2)}\n"
case _ =>
if (m._2.mutable) s"${indent} mut ${m._1}: ${convert(m._2)}\n"
else s"${indent} ${m._1}: ${convert(m._2)}\n"
}
case _ => "" // TODO: deal with private/protected members
}) :::
Expand Down
2 changes: 1 addition & 1 deletion ts2mls/js/src/main/scala/ts2mls/types/TSType.scala
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -7,7 +7,7 @@ case object Protected extends TSAccessModifier

sealed abstract class TSType
case class TSParameterType(name: String, val tp: TSType) extends TSType // record both parameter's name and parameter's type
case class TSMemberType(val base: TSType, val modifier: TSAccessModifier = Public) extends TSType
case class TSMemberType(val base: TSType, val modifier: TSAccessModifier = Public, val mutable: Boolean = false) extends TSType
case class TSTypeParameter(val name: String, constraint: Option[TSType] = None) extends TSType
case class TSPrimitiveType(typeName: String) extends TSType
case class TSReferenceType(name: String) extends TSType
Expand Down
14 changes: 10 additions & 4 deletions ts2mls/js/src/test/diff/Array.d.mls
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,7 +6,7 @@ fun first2(fs: MutArray<(number) => number>): (number) => number
fun doEs(e: MutArray<int>): MutArray<int>
class C() {}
trait I() {
let i: number
mut i: number
}
fun doCs(c: MutArray<C>): MutArray<C>
fun doIs(i: MutArray<I>): MutArray<I>
Expand All @@ -15,9 +15,15 @@ fun clean(x: MutArray<(string, number, )>): MutArray<(string, number, )>
fun translate<T, U>(x: MutArray<T>): MutArray<U>
fun uu(x: MutArray<((number) | (false)) | (true)>): MutArray<((number) | (false)) | (true)>
class Temp<T>() {
let x: T
mut x: T
}
fun ta(ts: MutArray<Temp<(false) | (true)>>): MutArray<Temp<(false) | (true)>>
fun tat<T>(ts: MutArray<Temp<T>>): MutArray<Temp<T>>
//│ |#fun| |first|(|x|#:| |MutArray|‹|string|›|)|#:| |string|↵|#fun| |getZero3|(||)|#:| |MutArray|‹|number|›|↵|#fun| |first2|(|fs|#:| |MutArray|‹|(|number|)| |=>| |number|›|)|#:| |(|number|)| |=>| |number|↵|#fun| |doEs|(|e|#:| |MutArray|‹|int|›|)|#:| |MutArray|‹|int|›|↵|#class| |C|(||)| |{||}|↵|#trait| |I|(||)| |{|→|#let| |i|#:| |number|←|↵|}|↵|#fun| |doCs|(|c|#:| |MutArray|‹|C|›|)|#:| |MutArray|‹|C|›|↵|#fun| |doIs|(|i|#:| |MutArray|‹|I|›|)|#:| |MutArray|‹|I|›|↵|#fun| |inter|‹|U|,| |T|›|(|x|#:| |MutArray|‹|(|U|)| |&| |(|T|)|›|)|#:| |MutArray|‹|(|U|)| |&| |(|T|)|›|↵|#fun| |clean|(|x|#:| |MutArray|‹|(|string|,| |number|,| |)|›|)|#:| |MutArray|‹|(|string|,| |number|,| |)|›|↵|#fun| |translate|‹|T|,| |U|›|(|x|#:| |MutArray|‹|T|›|)|#:| |MutArray|‹|U|›|↵|#fun| |uu|(|x|#:| |MutArray|‹|(|(|number|)| ||| |(|false|)|)| ||| |(|true|)|›|)|#:| |MutArray|‹|(|(|number|)| ||| |(|false|)|)| ||| |(|true|)|›|↵|#class| |Temp|‹|T|›|(||)| |{|→|#let| |x|#:| |T|←|↵|}|↵|#fun| |ta|(|ts|#:| |MutArray|‹|Temp|‹|(|false|)| ||| |(|true|)|›|›|)|#:| |MutArray|‹|Temp|‹|(|false|)| ||| |(|true|)|›|›|↵|#fun| |tat|‹|T|›|(|ts|#:| |MutArray|‹|Temp|‹|T|›|›|)|#:| |MutArray|‹|Temp|‹|T|›|›|
//│ Parsed: {fun first: [] -> (x: MutArray[string],) -> string; fun getZero3: [] -> () -> MutArray[number]; fun first2: [] -> (fs: MutArray[number -> number],) -> number -> number; fun doEs: [] -> (e: MutArray[int],) -> MutArray[int]; class C() {}; trait I() {let i: [] -> number}; fun doCs: [] -> (c: MutArray[C],) -> MutArray[C]; fun doIs: [] -> (i: MutArray[I],) -> MutArray[I]; fun inter: [] -> (x: MutArray[(U,) & (T,)],) -> MutArray[(U,) & (T,)]; fun clean: [] -> (x: MutArray[(string, number,)],) -> MutArray[(string, number,)]; fun translate: [] -> (x: MutArray[T],) -> MutArray[U]; fun uu: [] -> (x: MutArray[((number,) | (false,),) | (true,)],) -> MutArray[((number,) | (false,),) | (true,)]; class Temp‹T›() {let x: [] -> T}; fun ta: [] -> (ts: MutArray[Temp[(false,) | (true,)]],) -> MutArray[Temp[(false,) | (true,)]]; fun tat: [] -> (ts: MutArray[Temp[T]],) -> MutArray[Temp[T]]}
//│ |#fun| |first|(|x|#:| |MutArray|‹|string|›|)|#:| |string|↵|#fun| |getZero3|(||)|#:| |MutArray|‹|number|›|↵|#fun| |first2|(|fs|#:| |MutArray|‹|(|number|)| |=>| |number|›|)|#:| |(|number|)| |=>| |number|↵|#fun| |doEs|(|e|#:| |MutArray|‹|int|›|)|#:| |MutArray|‹|int|›|↵|#class| |C|(||)| |{||}|↵|#trait| |I|(||)| |{|→|#mut| |i|#:| |number|←|↵|}|↵|#fun| |doCs|(|c|#:| |MutArray|‹|C|›|)|#:| |MutArray|‹|C|›|↵|#fun| |doIs|(|i|#:| |MutArray|‹|I|›|)|#:| |MutArray|‹|I|›|↵|#fun| |inter|‹|U|,| |T|›|(|x|#:| |MutArray|‹|(|U|)| |&| |(|T|)|›|)|#:| |MutArray|‹|(|U|)| |&| |(|T|)|›|↵|#fun| |clean|(|x|#:| |MutArray|‹|(|string|,| |number|,| |)|›|)|#:| |MutArray|‹|(|string|,| |number|,| |)|›|↵|#fun| |translate|‹|T|,| |U|›|(|x|#:| |MutArray|‹|T|›|)|#:| |MutArray|‹|U|›|↵|#fun| |uu|(|x|#:| |MutArray|‹|(|(|number|)| ||| |(|false|)|)| ||| |(|true|)|›|)|#:| |MutArray|‹|(|(|number|)| ||| |(|false|)|)| ||| |(|true|)|›|↵|#class| |Temp|‹|T|›|(||)| |{|→|#mut| |x|#:| |T|←|↵|}|↵|#fun| |ta|(|ts|#:| |MutArray|‹|Temp|‹|(|false|)| ||| |(|true|)|›|›|)|#:| |MutArray|‹|Temp|‹|(|false|)| ||| |(|true|)|›|›|↵|#fun| |tat|‹|T|›|(|ts|#:| |MutArray|‹|Temp|‹|T|›|›|)|#:| |MutArray|‹|Temp|‹|T|›|›|
//│ ╔══[PARSE ERROR] Unexpected 'mut' keyword in expression position
//│ ║ l.9: mut i: number
//│ ╙── ^^^
//│ ╔══[PARSE ERROR] Unexpected 'mut' keyword in expression position
//│ ║ l.18: mut x: T
//│ ╙── ^^^
//│ Parsed: {fun first: [] -> (x: MutArray[string],) -> string; fun getZero3: [] -> () -> MutArray[number]; fun first2: [] -> (fs: MutArray[number -> number],) -> number -> number; fun doEs: [] -> (e: MutArray[int],) -> MutArray[int]; class C() {}; trait I() {i : TypeName(number)}; fun doCs: [] -> (c: MutArray[C],) -> MutArray[C]; fun doIs: [] -> (i: MutArray[I],) -> MutArray[I]; fun inter: [] -> (x: MutArray[(U,) & (T,)],) -> MutArray[(U,) & (T,)]; fun clean: [] -> (x: MutArray[(string, number,)],) -> MutArray[(string, number,)]; fun translate: [] -> (x: MutArray[T],) -> MutArray[U]; fun uu: [] -> (x: MutArray[((number,) | (false,),) | (true,)],) -> MutArray[((number,) | (false,),) | (true,)]; class Temp‹T›() {x : TypeName(T)}; fun ta: [] -> (ts: MutArray[Temp[(false,) | (true,)]],) -> MutArray[Temp[(false,) | (true,)]]; fun tat: [] -> (ts: MutArray[Temp[T]],) -> MutArray[Temp[T]]}
14 changes: 10 additions & 4 deletions ts2mls/js/src/test/diff/BasicFunctions.d.mls
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -15,14 +15,20 @@ fun create(): object
fun pa(x: number): number
fun wtf(x: anything): unit
class Foooooo() {
let ooooooo: number
mut ooooooo: number
}
fun inn(f: Foooooo): unit
fun out(): Foooooo
trait Barrrrrrrrr() {
let rrrrrrr: number
mut rrrrrrr: number
}
fun inn2(b: Barrrrrrrrr): unit
fun out2(): Barrrrrrrrr
//│ |#fun| |hello|(||)|#:| |unit|↵|#fun| |add|(|x|#:| |number|,| |y|#:| |number|)|#:| |number|↵|#fun| |sub|(|x|#:| |number|,| |y|#:| |number|)|#:| |number|↵|#fun| |foo|(||)|#:| |number|↵|#fun| |id|(|x|#:| |anything|)|#:| |anything|↵|#fun| |odd|(|x|#:| |number|)|#:| |(|false|)| ||| |(|true|)|↵|#fun| |isnull|(|x|#:| |anything|)|#:| |(|false|)| ||| |(|true|)|↵|#fun| |bar|(||)|#:| |anything|↵|#fun| |nu|(|n|#:| |null|)|#:| |null|↵|#fun| |un|(|n|#:| |undefined|)|#:| |undefined|↵|#fun| |fail|(||)|#:| |nothing|↵|#fun| |create|(||)|#:| |object|↵|#fun| |pa|(|x|#:| |number|)|#:| |number|↵|#fun| |wtf|(|x|#:| |anything|)|#:| |unit|↵|#class| |Foooooo|(||)| |{|→|#let| |ooooooo|#:| |number|←|↵|}|↵|#fun| |inn|(|f|#:| |Foooooo|)|#:| |unit|↵|#fun| |out|(||)|#:| |Foooooo|↵|#trait| |Barrrrrrrrr|(||)| |{|→|#let| |rrrrrrr|#:| |number|←|↵|}|↵|#fun| |inn2|(|b|#:| |Barrrrrrrrr|)|#:| |unit|↵|#fun| |out2|(||)|#:| |Barrrrrrrrr|
//│ Parsed: {fun hello: [] -> () -> unit; fun add: [] -> (x: number, y: number,) -> number; fun sub: [] -> (x: number, y: number,) -> number; fun foo: [] -> () -> number; fun id: [] -> (x: anything,) -> anything; fun odd: [] -> (x: number,) -> ((false,) | (true,)); fun isnull: [] -> (x: anything,) -> ((false,) | (true,)); fun bar: [] -> () -> anything; fun nu: [] -> (n: null,) -> null; fun un: [] -> (n: undefined,) -> undefined; fun fail: [] -> () -> nothing; fun create: [] -> () -> object; fun pa: [] -> (x: number,) -> number; fun wtf: [] -> (x: anything,) -> unit; class Foooooo() {let ooooooo: [] -> number}; fun inn: [] -> (f: Foooooo,) -> unit; fun out: [] -> () -> Foooooo; trait Barrrrrrrrr() {let rrrrrrr: [] -> number}; fun inn2: [] -> (b: Barrrrrrrrr,) -> unit; fun out2: [] -> () -> Barrrrrrrrr}
//│ |#fun| |hello|(||)|#:| |unit|↵|#fun| |add|(|x|#:| |number|,| |y|#:| |number|)|#:| |number|↵|#fun| |sub|(|x|#:| |number|,| |y|#:| |number|)|#:| |number|↵|#fun| |foo|(||)|#:| |number|↵|#fun| |id|(|x|#:| |anything|)|#:| |anything|↵|#fun| |odd|(|x|#:| |number|)|#:| |(|false|)| ||| |(|true|)|↵|#fun| |isnull|(|x|#:| |anything|)|#:| |(|false|)| ||| |(|true|)|↵|#fun| |bar|(||)|#:| |anything|↵|#fun| |nu|(|n|#:| |null|)|#:| |null|↵|#fun| |un|(|n|#:| |undefined|)|#:| |undefined|↵|#fun| |fail|(||)|#:| |nothing|↵|#fun| |create|(||)|#:| |object|↵|#fun| |pa|(|x|#:| |number|)|#:| |number|↵|#fun| |wtf|(|x|#:| |anything|)|#:| |unit|↵|#class| |Foooooo|(||)| |{|→|#mut| |ooooooo|#:| |number|←|↵|}|↵|#fun| |inn|(|f|#:| |Foooooo|)|#:| |unit|↵|#fun| |out|(||)|#:| |Foooooo|↵|#trait| |Barrrrrrrrr|(||)| |{|→|#mut| |rrrrrrr|#:| |number|←|↵|}|↵|#fun| |inn2|(|b|#:| |Barrrrrrrrr|)|#:| |unit|↵|#fun| |out2|(||)|#:| |Barrrrrrrrr|
//│ ╔══[PARSE ERROR] Unexpected 'mut' keyword in expression position
//│ ║ l.18: mut ooooooo: number
//│ ╙── ^^^
//│ ╔══[PARSE ERROR] Unexpected 'mut' keyword in expression position
//│ ║ l.23: mut rrrrrrr: number
//│ ╙── ^^^
//│ Parsed: {fun hello: [] -> () -> unit; fun add: [] -> (x: number, y: number,) -> number; fun sub: [] -> (x: number, y: number,) -> number; fun foo: [] -> () -> number; fun id: [] -> (x: anything,) -> anything; fun odd: [] -> (x: number,) -> ((false,) | (true,)); fun isnull: [] -> (x: anything,) -> ((false,) | (true,)); fun bar: [] -> () -> anything; fun nu: [] -> (n: null,) -> null; fun un: [] -> (n: undefined,) -> undefined; fun fail: [] -> () -> nothing; fun create: [] -> () -> object; fun pa: [] -> (x: number,) -> number; fun wtf: [] -> (x: anything,) -> unit; class Foooooo() {ooooooo : TypeName(number)}; fun inn: [] -> (f: Foooooo,) -> unit; fun out: [] -> () -> Foooooo; trait Barrrrrrrrr() {rrrrrrr : TypeName(number)}; fun inn2: [] -> (b: Barrrrrrrrr,) -> unit; fun out2: [] -> () -> Barrrrrrrrr}
Loading