@xnoxs/flux-lang 3.1.1

package/src/self/parser.flux

@@ -0,0 +1,1146 @@
+// ============================================================
+//  Flux Self-Hosted Parser
+//  src/self/parser.flux — written in Flux, compiled by stage-0
+// ============================================================
+
+import { T } from './lexer'
+
+fn makeParseError(msg, tok):
+  val line = tok?.line ?? '?'
+  val col  = tok?.col  ?? '?'
+  val err  = new Error("[Parser {line}:{col}] {msg}")
+  err.name = 'ParseError'
+  err.tok  = tok
+  return err
+
+export class Parser:
+  tokens: any[]
+  pos: int
+
+  fn peek(n = 0):
+    return self.tokens[self.pos + n] ?? { type: 'EOF', value: null, line: 0, col: 0 }
+
+  fn check(typ):
+    return self.peek().type == typ
+
+  fn at(a, b = null, c = null, d = null, e = null, f = null):
+    val t = self.peek().type
+    return t == a or (b != null and t == b) or (c != null and t == c) or (d != null and t == d) or (e != null and t == e) or (f != null and t == f)
+
+  fn eat(typ):
+    val tok = self.peek()
+    if tok.type != typ:
+      throw makeParseError("Expected '{typ}', got '{tok.type}' ({JSON.stringify(tok.value)})", tok)
+    self.pos = self.pos + 1
+    return tok
+
+  fn maybe(typ):
+    if self.check(typ):
+      self.pos = self.pos + 1
+      return true
+    return false
+
+  fn skip():
+    val t = self.tokens[self.pos]
+    self.pos = self.pos + 1
+    return t
+
+  fn skipNewlines():
+    while self.check(T.NEWLINE): self.pos = self.pos + 1
+
+  fn err(msg):
+    throw makeParseError(msg, self.peek())
+
+  fn parseBlock():
+    self.eat(T.COLON)
+    if self.check(T.NEWLINE):
+      self.pos = self.pos + 1
+      self.eat(T.INDENT)
+      val body = self.parseStmtList()
+      self.maybe(T.DEDENT)
+      return body
+    val stmt = self.parseOneStmt()
+    return [stmt]
+
+  fn parseStmtList():
+    val stmts = []
+    while not self.check(T.DEDENT) and not self.check(T.EOF):
+      self.skipNewlines()
+      if self.check(T.DEDENT) or self.check(T.EOF): break
+      stmts.push(self.parseOneStmt())
+    return stmts
+
+  fn parse():
+    self.skipNewlines()
+    val body = []
+    while not self.check(T.EOF):
+      self.skipNewlines()
+      if self.check(T.EOF): break
+      body.push(self.parseOneStmt())
+    return { type: 'Program', body }
+
+  fn parseOneStmt():
+    val tok = self.peek()
+    if tok.type == T.VAR or tok.type == T.VAL: return self.parseVarDecl()
+    if tok.type == T.FN:       return self.parseFnDecl(false)
+    if tok.type == T.ASYNC:    return self.parseAsyncFn()
+    if tok.type == T.CLASS:    return self.parseClassDecl()
+    if tok.type == T.IF:       return self.parseIf()
+    if tok.type == T.FOR:      return self.parseFor()
+    if tok.type == T.WHILE:    return self.parseWhile()
+    if tok.type == T.DO:       return self.parseDoWhile()
+    if tok.type == T.MATCH:    return self.parseMatch()
+    if tok.type == T.RETURN:   return self.parseReturn()
+    if tok.type == T.BREAK:
+      self.skip()
+      self.skipNewlines()
+      return { type: 'BreakStmt', loc: tok }
+    if tok.type == T.CONTINUE:
+      self.skip()
+      self.skipNewlines()
+      return { type: 'ContinueStmt', loc: tok }
+    if tok.type == T.IMPORT:    return self.parseImport()
+    if tok.type == T.EXPORT:    return self.parseExport()
+    if tok.type == T.TRY:       return self.parseTryCatch()
+    if tok.type == T.THROW:     return self.parseThrow()
+    if tok.type == T.TYPE:      return self.parseTypeDecl()
+    if tok.type == T.INTERFACE: return self.parseInterfaceDecl()
+    if tok.type == T.ENUM:      return self.parseEnumDecl()
+    return self.parseExprStmt()
+
+  fn parseVarDecl():
+    val kind = self.peek().type == T.VAR ? 'var' : 'val'
+    val loc  = self.skip()
+    if self.check(T.LBRACE):
+      val pattern = self.parseObjectDestructurePattern()
+      self.eat(T.EQ)
+      val init = self.parseExpr()
+      self.skipNewlines()
+      return { type: 'DestructureDecl', kind, patternType: 'object', pattern, init, loc }
+    if self.check(T.LBRACKET):
+      val pattern = self.parseArrayDestructurePattern()
+      self.eat(T.EQ)
+      val init = self.parseExpr()
+      self.skipNewlines()
+      return { type: 'DestructureDecl', kind, patternType: 'array', pattern, init, loc }
+    val name = self.eat(T.IDENT).value
+    var typeAnn = null
+    if self.maybe(T.COLON): typeAnn = self.parseTypeAnn()
+    var init = null
+    if self.maybe(T.EQ): init = self.parseExpr()
+    self.skipNewlines()
+    return { type: 'VarDecl', kind, name, typeAnn, init, loc }
+
+  fn parseObjectDestructurePattern():
+    self.eat(T.LBRACE)
+    val props = []
+    while not self.check(T.RBRACE) and not self.check(T.EOF):
+      var rest = false
+      if self.check(T.DOTDOTDOT):
+        self.pos = self.pos + 1
+        rest = true
+      val key = self.eat(T.IDENT).value
+      if rest:
+        props.push({ key, alias: key, rest: true })
+        break
+      var alias = key
+      if self.maybe(T.COLON): alias = self.eat(T.IDENT).value
+      var defaultVal = null
+      if self.maybe(T.EQ): defaultVal = self.parseExpr()
+      props.push({ key, alias, defaultVal, rest: false })
+      if not self.maybe(T.COMMA): break
+    self.eat(T.RBRACE)
+    return props
+
+  fn parseArrayDestructurePattern():
+    self.eat(T.LBRACKET)
+    val items = []
+    while not self.check(T.RBRACKET) and not self.check(T.EOF):
+      if self.check(T.COMMA):
+        items.push(null)
+        self.pos = self.pos + 1
+        continue
+      var rest = false
+      if self.check(T.DOTDOTDOT):
+        self.pos = self.pos + 1
+        rest = true
+      val name = self.eat(T.IDENT).value
+      var defaultVal = null
+      if self.maybe(T.EQ): defaultVal = self.parseExpr()
+      items.push({ name, defaultVal, rest })
+      if rest: break
+      if not self.maybe(T.COMMA): break
+    self.eat(T.RBRACKET)
+    return items
+
+  fn parseTypeAnn():
+    var name = self.parseIntersectionType()
+    while self.check(T.PIPEB):
+      self.pos = self.pos + 1
+      name = name + ' | ' + self.parseIntersectionType()
+    return name
+
+  fn parseIntersectionType():
+    var name = self.parseSingleType()
+    while self.check(T.AMPERSAND):
+      self.pos = self.pos + 1
+      name = name + ' & ' + self.parseSingleType()
+    return name
+
+  fn parseSingleType():
+    val tok = self.peek()
+    if tok.type == T.LBRACKET:
+      self.pos = self.pos + 1
+      val parts = []
+      while not self.check(T.RBRACKET) and not self.check(T.EOF):
+        parts.push(self.parseTypeAnn())
+        if not self.maybe(T.COMMA): break
+      self.eat(T.RBRACKET)
+      return '[' + parts.join(', ') + ']'
+    if tok.type == T.LBRACE:
+      self.pos = self.pos + 1
+      val pairs = []
+      while not self.check(T.RBRACE) and not self.check(T.EOF):
+        if self.check(T.LBRACKET):
+          self.pos = self.pos + 1
+          val iname = self.eat(T.IDENT).value
+          self.eat(T.COLON)
+          val iktype = self.parseTypeAnn()
+          self.eat(T.RBRACKET)
+          self.eat(T.COLON)
+          val ivtype = self.parseTypeAnn()
+          pairs.push("[{iname}: {iktype}]: {ivtype}")
+        else:
+          val key = self.at(T.IDENT, T.STRING) ? self.skip().value : self.eat(T.IDENT).value
+          var optional = false
+          if self.check(T.QUESTION):
+            self.pos = self.pos + 1
+            optional = true
+          self.eat(T.COLON)
+          val valType = self.parseTypeAnn()
+          val optStr = optional ? '?' : ''
+          pairs.push("{key}{optStr}: {valType}")
+        self.maybe(T.COMMA)
+      self.eat(T.RBRACE)
+      return '{ ' + pairs.join(', ') + ' }'
+    if tok.type == T.LPAREN:
+      self.pos = self.pos + 1
+      val inner = self.parseTypeAnn()
+      self.eat(T.RPAREN)
+      return '(' + inner + ')'
+    if tok.type == T.IDENT and tok.value == 'keyof':
+      self.pos = self.pos + 1
+      return 'keyof ' + self.parseSingleType()
+    if tok.type == T.TYPEOF:
+      self.pos = self.pos + 1
+      return 'typeof ' + self.eat(T.IDENT).value
+    if tok.type == T.READONLY:
+      self.pos = self.pos + 1
+      return 'readonly ' + self.parseSingleType()
+    if tok.type == T.IDENT and tok.value == 'infer':
+      self.pos = self.pos + 1
+      return 'infer ' + self.eat(T.IDENT).value
+    if tok.type == T.FN:
+      self.pos = self.pos + 1
+      val paramTypes = []
+      if self.check(T.LPAREN):
+        self.pos = self.pos + 1
+        while not self.check(T.RPAREN) and not self.check(T.EOF):
+          var pt = ''
+          if self.check(T.IDENT) and self.peek(1).type == T.COLON:
+            self.pos = self.pos + 2
+            pt = self.parseTypeAnn()
+          else:
+            pt = self.parseTypeAnn()
+          paramTypes.push(pt)
+          if not self.maybe(T.COMMA): break
+        self.eat(T.RPAREN)
+      var retType = 'Void'
+      if self.check(T.ARROW):
+        self.pos = self.pos + 1
+        retType = self.parseTypeAnn()
+      return 'fn(' + paramTypes.join(', ') + ') -> ' + retType
+    var name = ''
+    if tok.type == T.IDENT or tok.type == T.CONST or tok.type == T.TYPE:
+      name = self.skip().value
+    else:
+      name = self.eat(T.IDENT).value
+    if self.check(T.EXTENDS):
+      self.pos = self.pos + 1
+      val constraint = self.parseSingleType()
+      self.eat(T.QUESTION)
+      val thenType = self.parseTypeAnn()
+      self.eat(T.COLON)
+      val elseType = self.parseTypeAnn()
+      return "{name} extends {constraint} ? {thenType} : {elseType}"
+    if self.check(T.LT):
+      self.pos = self.pos + 1
+      val params = [self.parseTypeAnn()]
+      while self.maybe(T.COMMA): params.push(self.parseTypeAnn())
+      self.eat(T.GT)
+      name = name + '<' + params.join(', ') + '>'
+    while self.check(T.LBRACKET) and self.peek(1).type == T.RBRACKET:
+      self.pos = self.pos + 2
+      name = name + '[]'
+    if self.check(T.QUESTION) and self.peek(1).type != T.DOT:
+      self.pos = self.pos + 1
+      name = name + '?'
+    return name
+
+  fn isTypeAnnBeforeColon():
+    val saved = self.pos
+    try:
+      val tok0 = self.peek()
+      if tok0.type == T.LBRACKET or tok0.type == T.LBRACE or tok0.type == T.LPAREN:
+        var depth = 0
+        var i = 0
+        while self.tokens[self.pos + i] and self.tokens[self.pos + i].type != T.EOF:
+          val tt = self.tokens[self.pos + i].type
+          if tt == T.LBRACKET or tt == T.LBRACE or tt == T.LPAREN or tt == T.LT: depth = depth + 1
+          if tt == T.RBRACKET or tt == T.RBRACE or tt == T.RPAREN or tt == T.GT: depth = depth - 1
+          i = i + 1
+          if depth == 0: break
+        if self.tokens[self.pos + i] and self.tokens[self.pos + i].type == T.QUESTION: i = i + 1
+        val nextType = self.tokens[self.pos + i]?.type
+        self.pos = saved
+        return nextType == T.COLON
+      if tok0.type != T.IDENT and tok0.type != T.TYPEOF and tok0.type != T.READONLY and tok0.type != T.FN:
+        self.pos = saved
+        return false
+      self.parseTypeAnn()
+      val result = self.check(T.NEWLINE) or self.check(T.EOF)
+      self.pos = saved
+      return result
+    catch(e):
+      self.pos = saved
+      return false
+
+  fn isColonReturnType():
+    val saved = self.pos
+    try:
+      self.pos = self.pos + 1
+      if not self.at(T.IDENT, T.LBRACKET, T.LBRACE, T.LPAREN, T.FN, T.READONLY, T.TYPEOF):
+        self.pos = saved
+        return false
+      self.parseTypeAnn()
+      val result = self.check(T.NEWLINE) or self.check(T.EOF)
+      self.pos = saved
+      return result
+    catch(e):
+      self.pos = saved
+      return false
+
+  fn parseTypeDecl():
+    val loc = self.eat(T.TYPE)
+    val name = self.eat(T.IDENT).value
+    val typeParams = []
+    if self.check(T.LT):
+      self.pos = self.pos + 1
+      while not self.check(T.GT) and not self.check(T.EOF):
+        typeParams.push(self.eat(T.IDENT).value)
+        if not self.maybe(T.COMMA): break
+      self.eat(T.GT)
+    self.eat(T.EQ)
+    val variants = []
+    var running = true
+    while running:
+      val vname = self.eat(T.IDENT).value
+      val fields = []
+      val fieldTypes = {}
+      if self.check(T.LPAREN):
+        self.eat(T.LPAREN)
+        while not self.check(T.RPAREN) and not self.check(T.EOF):
+          val ftok = self.peek()
+          var fname = ''
+          if ftok.type == T.IDENT:
+            fname = self.skip().value
+          else:
+            fname = self.skip().value
+          if self.maybe(T.COLON):
+            fieldTypes[fname] = self.parseTypeAnn()
+          fields.push(fname)
+          if not self.maybe(T.COMMA): break
+        self.eat(T.RPAREN)
+      variants.push({ name: vname, fields, fieldTypes })
+      if not self.check(T.PIPEB): running = false
+      else: self.pos = self.pos + 1
+    self.skipNewlines()
+    return { type: 'TypeDecl', name, variants, loc }
+
+  fn parseInterfaceDecl():
+    val loc = self.eat(T.INTERFACE)
+    val name = self.eat(T.IDENT).value
+    val typeParams = []
+    if self.check(T.LT):
+      self.pos = self.pos + 1
+      while not self.check(T.GT) and not self.check(T.EOF):
+        typeParams.push(self.eat(T.IDENT).value)
+        if not self.maybe(T.COMMA): break
+      self.eat(T.GT)
+    val superInterfaces = []
+    if self.maybe(T.EXTENDS):
+      superInterfaces.push(self.eat(T.IDENT).value)
+      while self.maybe(T.COMMA): superInterfaces.push(self.eat(T.IDENT).value)
+    self.eat(T.COLON)
+    if self.check(T.NEWLINE): self.pos = self.pos + 1
+    self.eat(T.INDENT)
+    val members = []
+    while not self.check(T.DEDENT) and not self.check(T.EOF):
+      self.skipNewlines()
+      if self.check(T.DEDENT) or self.check(T.EOF): break
+      val mods = self.parseAccessModifiers()
+      if self.check(T.FN):
+        self.eat(T.FN)
+        val mname = self.eat(T.IDENT).value
+        val params = self.parseParamList()
+        var retType = null
+        if self.maybe(T.ARROW): retType = self.parseTypeAnn()
+        self.skipNewlines()
+        members.push({ kind: 'method', name: mname, params, retType, modifiers: mods, isAsync: false })
+      else if self.check(T.IDENT):
+        val fname = self.eat(T.IDENT).value
+        var optional = false
+        if self.check(T.QUESTION):
+          self.pos = self.pos + 1
+          optional = true
+        self.eat(T.COLON)
+        val ftype = self.parseTypeAnn()
+        self.skipNewlines()
+        members.push({ kind: 'field', name: fname, typeAnn: ftype, optional, modifiers: mods })
+      else:
+        self.skip()
+    self.maybe(T.DEDENT)
+    return { type: 'InterfaceDecl', name, typeParams, superInterfaces, members, loc }
+
+  fn parseEnumDecl():
+    val loc = self.eat(T.ENUM)
+    val name = self.eat(T.IDENT).value
+    self.eat(T.COLON)
+    if self.check(T.NEWLINE):
+      self.pos = self.pos + 1
+      self.eat(T.INDENT)
+    val members = []
+    var autoIndex = 0
+    while not self.check(T.DEDENT) and not self.check(T.EOF):
+      self.skipNewlines()
+      if self.check(T.DEDENT) or self.check(T.EOF): break
+      val mname = self.eat(T.IDENT).value
+      var value = { type: 'NumberLit', value: autoIndex }
+      if self.maybe(T.EQ):
+        val parsed = self.parseExpr()
+        value = parsed
+        if parsed.type == 'NumberLit': autoIndex = parsed.value
+      else:
+        value = { type: 'NumberLit', value: autoIndex }
+      autoIndex = autoIndex + 1
+      self.skipNewlines()
+      members.push({ name: mname, value })
+    self.maybe(T.DEDENT)
+    return { type: 'EnumDecl', name, members, loc }
+
+  fn parseIf():
+    val loc = self.eat(T.IF)
+    val cond = self.parseExpr()
+    val then = self.parseBlock()
+    val elseifs = []
+    var else_ = null
+    self.skipNewlines()
+    while self.check(T.ELSE):
+      self.pos = self.pos + 1
+      if self.check(T.IF):
+        self.pos = self.pos + 1
+        val eic = self.parseExpr()
+        val eib = self.parseBlock()
+        elseifs.push({ cond: eic, body: eib })
+        self.skipNewlines()
+      else:
+        else_ = self.parseBlock()
+        break
+    return { type: 'IfStmt', cond, then, elseifs, else_, loc }
+
+  fn parseFor():
+    val loc = self.eat(T.FOR)
+    var isAwait = false
+    if self.check(T.AWAIT):
+      self.pos = self.pos + 1
+      isAwait = true
+    val varName = self.eat(T.IDENT).value
+    self.eat(T.IN)
+    val iter = self.parseExpr()
+    val body = self.parseBlock()
+    return { type: 'ForInStmt', "var": varName, iter, body, isAwait, loc }
+
+  fn parseWhile():
+    val loc = self.eat(T.WHILE)
+    val cond = self.parseExpr()
+    val body = self.parseBlock()
+    return { type: 'WhileStmt', cond, body, loc }
+
+  fn parseDoWhile():
+    val loc = self.eat(T.DO)
+    val body = self.parseBlock()
+    self.skipNewlines()
+    self.eat(T.WHILE)
+    val cond = self.parseExpr()
+    self.skipNewlines()
+    return { type: 'DoWhileStmt', body, cond, loc }
+
+  fn parseMatch():
+    val loc = self.eat(T.MATCH)
+    val subject = self.parseExpr()
+    self.eat(T.COLON)
+    if self.check(T.NEWLINE): self.pos = self.pos + 1
+    self.eat(T.INDENT)
+    val arms = []
+    while not self.check(T.DEDENT) and not self.check(T.EOF):
+      self.skipNewlines()
+      if self.check(T.DEDENT) or self.check(T.EOF): break
+      self.eat(T.WHEN)
+      val pattern = self.parsePattern()
+      var guard = null
+      if self.check(T.IF):
+        self.pos = self.pos + 1
+        guard = self.parseExpr()
+      if self.check(T.ARROW):
+        self.pos = self.pos + 1
+        val expr = self.parseExpr()
+        self.skipNewlines()
+        arms.push({ pattern, guard, body: [{ type: 'ExprStmt', expr }], inline: true })
+      else if self.check(T.COLON):
+        val isInline = self.peek(1).type != T.NEWLINE
+        val body = self.parseBlock()
+        val inlineArm = isInline and body.length == 1 and body[0].type == 'ExprStmt'
+        arms.push({ pattern, guard, body, inline: inlineArm })
+    self.maybe(T.DEDENT)
+    return { type: 'MatchStmt', subject, arms, loc }
+
+  fn parsePattern():
+    if self.check(T.WILDCARD):
+      self.skip()
+      return { type: 'WildcardPat' }
+    if self.check(T.IDENT) and self.peek(1).type == T.LPAREN:
+      val vname = self.eat(T.IDENT).value
+      self.eat(T.LPAREN)
+      val bindings = []
+      while not self.check(T.RPAREN) and not self.check(T.EOF):
+        if self.check(T.WILDCARD):
+          bindings.push('_')
+          self.pos = self.pos + 1
+        else:
+          bindings.push(self.eat(T.IDENT).value)
+        if not self.maybe(T.COMMA): break
+      self.eat(T.RPAREN)
+      return { type: 'VariantPat', variant: vname, bindings }
+    var left = self.parsePrimary()
+    while self.check(T.DOT):
+      self.pos = self.pos + 1
+      val prop = self.skip().value
+      left = { type: 'MemberExpr', obj: left, prop }
+    if self.check(T.DOTDOT):
+      self.pos = self.pos + 1
+      val right = self.parsePrimary()
+      return { type: 'RangePat', start: left, end: right }
+    return { type: 'LiteralPat', value: left }
+
+  fn parseReturn():
+    val loc = self.eat(T.RETURN)
+    var value = null
+    if not self.at(T.NEWLINE, T.EOF, T.DEDENT):
+      value = self.parseExpr()
+    self.skipNewlines()
+    return { type: 'ReturnStmt', value, loc }
+
+  fn parseTryCatch():
+    val loc = self.eat(T.TRY)
+    val tryBody = self.parseBlock()
+    var catchParam = null
+    var catchBody  = null
+    var finallyBody = null
+    self.skipNewlines()
+    if self.check(T.CATCH):
+      self.pos = self.pos + 1
+      if self.check(T.LPAREN):
+        self.pos = self.pos + 1
+        catchParam = self.eat(T.IDENT).value
+        if self.maybe(T.COLON): self.parseTypeAnn()
+        self.eat(T.RPAREN)
+      catchBody = self.parseBlock()
+      self.skipNewlines()
+    if self.check(T.FINALLY):
+      self.pos = self.pos + 1
+      finallyBody = self.parseBlock()
+    return { type: 'TryCatchStmt', tryBody, catchParam, catchBody, finallyBody, loc }
+
+  fn parseThrow():
+    val loc = self.eat(T.THROW)
+    val value = self.parseExpr()
+    self.skipNewlines()
+    return { type: 'ThrowStmt', value, loc }
+
+  fn parseImport():
+    self.eat(T.IMPORT)
+    if self.check(T.STAR):
+      self.pos = self.pos + 1
+      self.eat(T.AS)
+      val namespaceName = self.eat(T.IDENT).value
+      self.eat(T.FROM)
+      val source = self.eat(T.STRING).value
+      self.skipNewlines()
+      return { type: 'ImportDecl', names: [], defaultName: null, namespaceName, source }
+    if self.check(T.IDENT):
+      val defaultName = self.eat(T.IDENT).value
+      self.eat(T.FROM)
+      val source = self.eat(T.STRING).value
+      self.skipNewlines()
+      return { type: 'ImportDecl', names: [], defaultName, source }
+    val names = []
+    if self.maybe(T.LBRACE):
+      while not self.check(T.RBRACE) and not self.check(T.EOF):
+        val name = self.eat(T.IDENT).value
+        var alias = name
+        if self.check(T.AS):
+          self.pos = self.pos + 1
+          alias = self.eat(T.IDENT).value
+        names.push({ name, alias })
+        if not self.maybe(T.COMMA): break
+      self.eat(T.RBRACE)
+    self.eat(T.FROM)
+    val source = self.eat(T.STRING).value
+    self.skipNewlines()
+    return { type: 'ImportDecl', names, defaultName: null, source }
+
+  fn parseExport():
+    self.eat(T.EXPORT)
+    if self.check(T.DEFAULT):
+      self.pos = self.pos + 1
+      if self.check(T.ASYNC):
+        self.pos = self.pos + 1
+        val decl = self.parseFnDecl(true)
+        return { type: 'ExportDecl', isDefault: true, decl }
+      if self.check(T.FN):
+        val decl = self.parseFnDecl(false)
+        return { type: 'ExportDecl', isDefault: true, decl }
+      val value = self.parseExpr()
+      self.skipNewlines()
+      return { type: 'ExportDecl', isDefault: true, decl: value }
+    if self.check(T.ASYNC):
+      self.pos = self.pos + 1
+      if not self.check(T.FN): self.err('Expected fn after async')
+      val decl = self.parseFnDecl(true)
+      return { type: 'ExportDecl', isDefault: false, decl }
+    val decl = self.parseOneStmt()
+    return { type: 'ExportDecl', isDefault: false, decl }
+
+  fn parseFnDecl(isAsync = false):
+    val loc = self.eat(T.FN)
+    var name = null
+    if self.check(T.IDENT) or self.check(T.NEW) or self.check(T.FROM) or self.check(T.AS) or self.check(T.DEFAULT) or self.check(T.IS) or self.check(T.IN) or self.check(T.TYPE):
+      name = self.skip().value
+    val params = self.parseParamList()
+    var retType = null
+    if self.check(T.ARROW):
+      self.pos = self.pos + 1
+      if self.isTypeAnnBeforeColon():
+        retType = self.parseTypeAnn()
+        val body = self.parseBlock()
+        return { type: 'FnDecl', name, params, retType, body, inline: false, async: isAsync, loc }
+      val body = self.parseExpr()
+      self.skipNewlines()
+      return { type: 'FnDecl', name, params, retType: null, body, inline: true, async: isAsync, loc }
+    if self.check(T.COLON):
+      if self.isColonReturnType():
+        self.pos = self.pos + 1
+        retType = self.parseTypeAnn()
+        if self.check(T.NEWLINE): self.pos = self.pos + 1
+        if self.check(T.INDENT):
+          self.pos = self.pos + 1
+          val body = self.parseStmtList()
+          self.maybe(T.DEDENT)
+          return { type: 'FnDecl', name, params, retType, body, inline: false, async: isAsync, loc }
+        val stmt = self.parseOneStmt()
+        return { type: 'FnDecl', name, params, retType, body: [stmt], inline: false, async: isAsync, loc }
+      val body = self.parseBlock()
+      return { type: 'FnDecl', name, params, retType: null, body, inline: false, async: isAsync, loc }
+    self.err('Expected -> or : after function signature')
+
+  fn parseAsyncFn():
+    self.eat(T.ASYNC)
+    if not self.check(T.FN): self.err('Expected fn after async')
+    return self.parseFnDecl(true)
+
+  fn parseParamList():
+    self.eat(T.LPAREN)
+    val params = []
+    while not self.check(T.RPAREN) and not self.check(T.EOF):
+      var rest = false
+      if self.check(T.DOTDOTDOT):
+        self.pos = self.pos + 1
+        rest = true
+      val name = self.eat(T.IDENT).value
+      var optional = false
+      var typeAnn = null
+      if not rest and self.check(T.QUESTION):
+        self.pos = self.pos + 1
+        optional = true
+      if not rest and self.maybe(T.COLON): typeAnn = self.parseTypeAnn()
+      var defaultVal = null
+      if not rest and self.maybe(T.EQ): defaultVal = self.parseExpr()
+      params.push({ name, typeAnn, optional, defaultVal, rest })
+      if rest: break
+      if not self.maybe(T.COMMA): break
+    self.eat(T.RPAREN)
+    return params
+
+  fn parseAccessModifiers():
+    val mods = new Set([])
+    var running = true
+    while running:
+      val t = self.peek().type
+      if t == T.PRIVATE or t == T.PUBLIC or t == T.PROTECTED or t == T.READONLY or t == T.STATIC or t == T.ABSTRACT or t == T.OVERRIDE:
+        mods.add(self.skip().value)
+      else:
+        running = false
+    return mods
+
+  fn parseClassDecl():
+    val loc = self.eat(T.CLASS)
+    val name = self.eat(T.IDENT).value
+    var superClass = null
+    val interfaces = []
+    val typeParams = []
+    if self.check(T.LT):
+      self.pos = self.pos + 1
+      typeParams.push(self.eat(T.IDENT).value)
+      while self.maybe(T.COMMA): typeParams.push(self.eat(T.IDENT).value)
+      self.eat(T.GT)
+    if self.maybe(T.EXTENDS): superClass = self.eat(T.IDENT).value
+    if self.maybe(T.IMPLEMENTS):
+      interfaces.push(self.eat(T.IDENT).value)
+      while self.maybe(T.COMMA): interfaces.push(self.eat(T.IDENT).value)
+    self.eat(T.COLON)
+    if self.check(T.NEWLINE):
+      self.pos = self.pos + 1
+      self.eat(T.INDENT)
+    val fields = []
+    val methods = []
+    while not self.check(T.DEDENT) and not self.check(T.EOF):
+      self.skipNewlines()
+      if self.check(T.DEDENT) or self.check(T.EOF): break
+      val mods = self.parseAccessModifiers()
+      if self.check(T.FN):
+        val m = self.parseFnDecl(false)
+        m.modifiers = mods
+        methods.push(m)
+      else if self.check(T.ASYNC):
+        val m = self.parseAsyncFn()
+        m.modifiers = mods
+        methods.push(m)
+      else if self.check(T.STATIC) and self.peek(1).type == T.FN:
+        self.skip()
+        val m = self.parseFnDecl(false)
+        m.modifiers = mods
+        m.modifiers.add('static')
+        methods.push(m)
+      else if self.check(T.IDENT):
+        val fname = self.eat(T.IDENT).value
+        var optional = false
+        if self.check(T.QUESTION):
+          self.pos = self.pos + 1
+          optional = true
+        self.eat(T.COLON)
+        val ftype = self.parseTypeAnn()
+        self.skipNewlines()
+        fields.push({ name: fname, typeAnn: ftype, optional, modifiers: mods })
+      else:
+        self.skip()
+    self.maybe(T.DEDENT)
+    return { type: 'ClassDecl', name, typeParams, superClass, interfaces, fields, methods, loc }
+
+  fn parseExprStmt():
+    val expr = self.parseExpr()
+    self.skipNewlines()
+    return { type: 'ExprStmt', expr }
+
+  fn parseExpr():
+    return self.parsePipe()
+
+  fn parsePipe():
+    var left = self.parseAssign()
+    var running = true
+    while running:
+      if self.check(T.PIPE):
+        self.pos = self.pos + 1
+        val right = self.parseAssign()
+        left = { type: 'PipeExpr', left, right }
+      else if self.check(T.NEWLINE):
+        var i = 1
+        while self.peek(i).type == T.NEWLINE: i = i + 1
+        if self.peek(i).type == T.PIPE:
+          while self.check(T.NEWLINE): self.pos = self.pos + 1
+          self.pos = self.pos + 1
+          val right = self.parseAssign()
+          left = { type: 'PipeExpr', left, right }
+        else:
+          running = false
+      else:
+        running = false
+    return left
+
+  fn parseAssign():
+    val left = self.parseTernary()
+    val t = self.peek().type
+    var op = ""
+    if t == T.EQ: op = '='
+    else if t == T.PLUSEQ: op = '+='
+    else if t == T.MINUSEQ: op = '-='
+    else if t == T.STAREQ: op = '*='
+    else if t == T.SLASHEQ: op = '/='
+    else if t == T.PERCENTEQ: op = '%='
+    if op:
+      self.pos = self.pos + 1
+      return { type: 'AssignExpr', target: left, op, value: self.parseAssign() }
+    return left
+
+  fn parseTernary():
+    val cond = self.parseNullish()
+    if self.maybe(T.QUESTION):
+      val then = self.parseNullish()
+      self.eat(T.COLON)
+      val else_ = self.parseTernary()
+      return { type: 'TernaryExpr', cond, then, else_ }
+    return cond
+
+  fn parseNullish():
+    var l = self.parseOr()
+    while self.check(T.NULLISH):
+      self.pos = self.pos + 1
+      val r = self.parseOr()
+      l = { type: 'BinaryExpr', op: '??', left: l, right: r }
+    return l
+
+  fn parseOr():
+    var l = self.parseAnd()
+    while self.check(T.OR) or self.check(T.OROR):
+      self.pos = self.pos + 1
+      val r = self.parseAnd()
+      l = { type: 'BinaryExpr', op: '||', left: l, right: r }
+    return l
+
+  fn parseAnd():
+    var l = self.parseBitOr()
+    while self.check(T.AND) or self.check(T.ANDAND):
+      self.pos = self.pos + 1
+      val r = self.parseBitOr()
+      l = { type: 'BinaryExpr', op: '&&', left: l, right: r }
+    return l
+
+  fn parseBitOr():
+    var l = self.parseBitXor()
+    while self.check(T.PIPEB):
+      self.pos = self.pos + 1
+      val r = self.parseBitXor()
+      l = { type: 'BinaryExpr', op: '|', left: l, right: r }
+    return l
+
+  fn parseBitXor():
+    var l = self.parseBitAnd()
+    while self.check(T.CARET):
+      self.pos = self.pos + 1
+      val r = self.parseBitAnd()
+      l = { type: 'BinaryExpr', op: '^', left: l, right: r }
+    return l
+
+  fn parseBitAnd():
+    var l = self.parseEq()
+    while self.check(T.AMPERSAND):
+      self.pos = self.pos + 1
+      val r = self.parseEq()
+      l = { type: 'BinaryExpr', op: '&', left: l, right: r }
+    return l
+
+  fn parseEq():
+    var l = self.parseRel()
+    while self.at(T.EQEQ, T.NEQ, T.EQEQEQ, T.NEQEQ):
+      val op = self.skip().value
+      val r = self.parseRel()
+      l = { type: 'BinaryExpr', op, left: l, right: r }
+    return l
+
+  fn parseRel():
+    var l = self.parseShift()
+    while self.at(T.LT, T.LTE, T.GT, T.GTE) or self.check(T.IN):
+      val op = self.skip().value
+      val r = self.parseShift()
+      l = { type: 'BinaryExpr', op, left: l, right: r }
+    return l
+
+  fn parseShift():
+    var l = self.parseRange()
+    while self.at(T.LSHIFT, T.RSHIFT):
+      val op = self.skip().value
+      val r = self.parseRange()
+      l = { type: 'BinaryExpr', op, left: l, right: r }
+    return l
+
+  fn parseRange():
+    val l = self.parseAdd()
+    if self.check(T.DOTDOT):
+      self.pos = self.pos + 1
+      val r = self.parseAdd()
+      return { type: 'RangeExpr', start: l, end: r }
+    return l
+
+  fn parseAdd():
+    var l = self.parseMul()
+    while self.at(T.PLUS, T.MINUS):
+      val op = self.skip().value
+      val r = self.parseMul()
+      l = { type: 'BinaryExpr', op, left: l, right: r }
+    return l
+
+  fn parseMul():
+    var l = self.parsePow()
+    while self.at(T.STAR, T.SLASH, T.PERCENT):
+      val op = self.skip().value
+      val r = self.parsePow()
+      l = { type: 'BinaryExpr', op, left: l, right: r }
+    return l
+
+  fn parsePow():
+    val l = self.parseUnary()
+    if self.check(T.STARSTAR):
+      self.pos = self.pos + 1
+      return { type: 'BinaryExpr', op: '**', left: l, right: self.parsePow() }
+    return l
+
+  fn parseUnary():
+    if self.check(T.MINUS):
+      self.pos = self.pos + 1
+      return { type: 'UnaryExpr', op: '-', operand: self.parseUnary() }
+    if self.check(T.NOT):
+      self.pos = self.pos + 1
+      return { type: 'UnaryExpr', op: '!', operand: self.parseUnary() }
+    if self.check(T.BANG):
+      self.pos = self.pos + 1
+      return { type: 'UnaryExpr', op: '!', operand: self.parseUnary() }
+    if self.check(T.TILDE):
+      self.pos = self.pos + 1
+      return { type: 'UnaryExpr', op: '~', operand: self.parseUnary() }
+    if self.check(T.PLUSPLUS):
+      self.pos = self.pos + 1
+      return { type: 'UpdateExpr', op: '++', prefix: true, operand: self.parseUnary() }
+    if self.check(T.MINUSMINUS):
+      self.pos = self.pos + 1
+      return { type: 'UpdateExpr', op: '--', prefix: true, operand: self.parseUnary() }
+    if self.check(T.AWAIT):
+      self.pos = self.pos + 1
+      return { type: 'AwaitExpr', operand: self.parseUnary() }
+    if self.check(T.TYPEOF):
+      self.pos = self.pos + 1
+      return { type: 'TypeofExpr', operand: self.parseUnary() }
+    return self.parseLambdaOrPostfix()
+
+  fn parseLambdaOrPostfix():
+    val saved = self.pos
+    if self.check(T.IDENT) or self.check(T.WILDCARD):
+      val name = self.skip().value ?? '_'
+      if self.check(T.ARROW):
+        self.pos = self.pos + 1
+        val body = self.parseExpr()
+        return { type: 'LambdaExpr', params: [{ name }], body }
+      self.pos = saved
+    return self.parsePostfix()
+
+  fn parsePostfix():
+    var expr = self.parsePrimary()
+    var running = true
+    while running:
+      if self.check(T.PLUSPLUS):
+        self.pos = self.pos + 1
+        expr = { type: 'UpdateExpr', op: '++', prefix: false, operand: expr }
+      else if self.check(T.MINUSMINUS):
+        self.pos = self.pos + 1
+        expr = { type: 'UpdateExpr', op: '--', prefix: false, operand: expr }
+      else if self.check(T.DOT):
+        self.pos = self.pos + 1
+        val propTok = self.peek()
+        val prop = self.skip().value
+        expr = { type: 'MemberExpr', obj: expr, prop }
+      else if self.check(T.QUESTIONDOT):
+        self.pos = self.pos + 1
+        if self.check(T.LPAREN):
+          val args = self.parseArgList()
+          expr = { type: 'OptCallExpr', callee: expr, args }
+        else if self.check(T.LBRACKET):
+          self.pos = self.pos + 1
+          val idx = self.parseExpr()
+          self.eat(T.RBRACKET)
+          expr = { type: 'OptIndexExpr', obj: expr, idx }
+        else:
+          val prop = self.skip().value
+          expr = { type: 'OptMemberExpr', obj: expr, prop }
+      else if self.check(T.INSTANCEOF):
+        self.pos = self.pos + 1
+        val right = self.eat(T.IDENT).value
+        expr = { type: 'BinaryExpr', op: 'instanceof', left: expr, right: { type: 'Identifier', name: right } }
+      else if self.check(T.AS):
+        self.pos = self.pos + 1
+        if self.check(T.CONST):
+          self.pos = self.pos + 1
+          expr = { type: 'AsConstExpr', expr }
+        else:
+          val castType = self.parseTypeAnn()
+          expr = { type: 'CastExpr', expr, castType }
+      else if self.check(T.SATISFIES):
+        self.pos = self.pos + 1
+        val satType = self.parseTypeAnn()
+        expr = { type: 'SatisfiesExpr', expr, satType }
+      else if self.check(T.IS):
+        self.pos = self.pos + 1
+        val isType = self.parseTypeAnn()
+        expr = { type: 'IsExpr', expr, isType }
+      else if self.check(T.BANG):
+        self.pos = self.pos + 1
+        expr = { type: 'NonNullExpr', expr }
+      else if self.check(T.LBRACKET):
+        self.pos = self.pos + 1
+        val idx = self.parseExpr()
+        self.eat(T.RBRACKET)
+        expr = { type: 'IndexExpr', obj: expr, idx }
+      else if self.check(T.LPAREN):
+        val args = self.parseArgList()
+        if self.check(T.ARROW):
+          self.pos = self.pos + 1
+          val body  = self.parseExpr()
+          val lambdaParams = args.map(a -> ({ name: a.type == 'Identifier' ? a.name : '_' }))
+          return { type: 'LambdaExpr', params: lambdaParams, body }
+        expr = { type: 'CallExpr', callee: expr, args }
+      else:
+        running = false
+    return expr
+
+  fn parseArgList():
+    self.eat(T.LPAREN)
+    val args = []
+    while not self.check(T.RPAREN) and not self.check(T.EOF):
+      if self.check(T.DOTDOTDOT):
+        self.pos = self.pos + 1
+        args.push({ type: 'SpreadExpr', expr: self.parseExpr() })
+      else:
+        args.push(self.parseExpr())
+      if not self.maybe(T.COMMA): break
+    self.eat(T.RPAREN)
+    return args
+
+  fn parsePrimary():
+    val tok = self.peek()
+    if tok.type == T.NUMBER:
+      self.pos = self.pos + 1
+      return { type: 'NumberLit', value: tok.value, loc: tok }
+    if tok.type == T.BOOL:
+      self.pos = self.pos + 1
+      return { type: 'BoolLit', value: tok.value, loc: tok }
+    if tok.type == T.NULL:
+      self.pos = self.pos + 1
+      return { type: 'NullLit', loc: tok }
+    if tok.type == T.SELF:
+      self.pos = self.pos + 1
+      return { type: 'SelfExpr', loc: tok }
+    if tok.type == T.WILDCARD:
+      self.pos = self.pos + 1
+      return { type: 'Identifier', name: '_', loc: tok }
+    if tok.type == T.IDENT:
+      self.pos = self.pos + 1
+      return { type: 'Identifier', name: tok.value, loc: tok }
+    if tok.type == T.STRING:
+      self.pos = self.pos + 1
+      if tok.value and tok.value.template:
+        return { type: 'TemplateLit', parts: tok.value.parts, loc: tok }
+      return { type: 'StringLit', value: tok.value, loc: tok }
+    if tok.type == T.REGEX:
+      self.pos = self.pos + 1
+      return { type: 'RegexLit', value: tok.value, loc: tok }
+    if tok.type == T.NEW:
+      self.pos = self.pos + 1
+      val callee = self.eat(T.IDENT).value
+      val args = self.parseArgList()
+      return { type: 'NewExpr', callee, args }
+    if tok.type == T.MATCH:
+      return self.parseMatch()
+    if tok.type == T.FN:
+      self.pos = self.pos + 1
+      val params = self.parseParamList()
+      if self.check(T.ARROW):
+        self.pos = self.pos + 1
+        if self.isTypeAnnBeforeColon():
+          val retType = self.parseTypeAnn()
+          val body = self.parseBlock()
+          return { type: 'FnDecl', name: null, params, retType, body, inline: false, async: false, loc: tok }
+        val body = self.parseExpr()
+        return { type: 'FnDecl', name: null, params, retType: null, body, inline: true, async: false, loc: tok }
+      if self.check(T.COLON):
+        val body = self.parseBlock()
+        return { type: 'FnDecl', name: null, params, retType: null, body, inline: false, async: false, loc: tok }
+      self.err('Expected -> or : after anonymous fn')
+    if tok.type == T.LPAREN:
+      self.pos = self.pos + 1
+      if self.check(T.RPAREN):
+        self.pos = self.pos + 1
+        if self.check(T.ARROW):
+          self.pos = self.pos + 1
+          val body = self.parseExpr()
+          return { type: 'LambdaExpr', params: [], body }
+        return { type: 'NullLit' }
+      val first = self.parseExpr()
+      if self.check(T.RPAREN):
+        self.pos = self.pos + 1
+        if self.check(T.ARROW):
+          self.pos = self.pos + 1
+          val body = self.parseExpr()
+          val pname = first.type == 'Identifier' ? first.name : '_'
+          return { type: 'LambdaExpr', params: [{ name: pname }], body }
+        return first
+      val items = [first]
+      while self.maybe(T.COMMA): items.push(self.parseExpr())
+      self.eat(T.RPAREN)
+      if self.check(T.ARROW):
+        self.pos = self.pos + 1
+        val body = self.parseExpr()
+        val lambdaParams = items.map(i -> ({ name: i.type == 'Identifier' ? i.name : '_' }))
+        return { type: 'LambdaExpr', params: lambdaParams, body }
+      return items[0]
+    if tok.type == T.LBRACKET:
+      self.pos = self.pos + 1
+      val items = []
+      while not self.check(T.RBRACKET) and not self.check(T.EOF):
+        if self.check(T.DOTDOTDOT):
+          self.pos = self.pos + 1
+          items.push({ type: 'SpreadExpr', expr: self.parseExpr() })
+        else:
+          items.push(self.parseExpr())
+        if not self.maybe(T.COMMA): break
+      self.eat(T.RBRACKET)
+      return { type: 'ArrayExpr', items }
+    if tok.type == T.LBRACE:
+      self.pos = self.pos + 1
+      val pairs = []
+      while not self.check(T.RBRACE) and not self.check(T.EOF):
+        if self.check(T.DOTDOTDOT):
+          self.pos = self.pos + 1
+          pairs.push({ spread: true, value: self.parseExpr() })
+          if not self.maybe(T.COMMA): break
+          continue
+        val key = self.check(T.STRING) ? self.eat(T.STRING).value : (self.check(T.IDENT) ? self.skip().value : self.skip().value)
+        if not self.check(T.COLON):
+          pairs.push({ key, value: { type: 'Identifier', name: key } })
+        else:
+          self.eat(T.COLON)
+          val v = self.parseExpr()
+          pairs.push({ key, value: v })
+        if not self.maybe(T.COMMA): break
+      self.eat(T.RBRACE)
+      return { type: 'ObjectExpr', pairs }
+    self.err("Unexpected token: {tok.type} ({JSON.stringify(tok.value)})")
+
+export fn makeParser(tokens):
+  return new Parser(tokens, 0)