xbintsc 0.2.4 → 0.2.6

package/src/lexer/scanner.ts

@@ -240,12 +240,12 @@ export class Scanner {
     const cleaned = raw.replace(/_/g, "");
     if (isBigInt) {
       raw = raw.slice(0, -1).replace(/_/g, "");
-      try {
-        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, BigInt(raw));
-      } catch {
+      const parsed = Number(raw);
+      if (parsed !== parsed) {
         this.error(DiagnosticCode.InvalidNumber, `Invalid BigInt literal '${raw}'`, start, this.pos);
-        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, 0n);
+        return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, 0);
       }
+      return this.makeToken(TokenKind.BigIntLiteral, start, this.pos, raw, precededByLineBreak, parsed);
     }
     let value: number;
     if (/^0[xX]/.test(cleaned)) value = parseInt(cleaned.slice(2), 16);

package/src/lexer/token.ts

@@ -264,3 +264,76 @@ export const CONTEXTUAL_KEYWORDS: ReadonlySet<TokenKind> = new Set([
 export function isOfKeyword(token: Token): boolean {
   return token.kind === TokenKind.Identifier && token.text === "of";
 }
+
+/** Every keyword token kind, derived from the scanner's keyword table. */
+export const KEYWORD_KINDS: ReadonlySet<TokenKind> = new Set(KEYWORDS.values());
+
+/**
+ * True for the hard/contextual keywords the scanner emits. Property names and
+ * member access allow any of these (`obj.default`, `{ type: 1 }`), so the
+ * parser consults this instead of maintaining a hand-written allow list.
+ */
+export function isKeywordKind(kind: TokenKind): boolean {
+  return KEYWORD_KINDS.has(kind);
+}
+
+/**
+ * Keywords that can never be used as a plain binding/identifier. Everything
+ * else the scanner recognizes is a TypeScript contextual keyword (`type`,
+ * `async`, `module`, `namespace`, `readonly`, …) and may legally name a
+ * variable, parameter or property.
+ */
+const RESERVED_KEYWORDS: ReadonlySet<TokenKind> = new Set([
+  TokenKind.BreakKeyword,
+  TokenKind.CaseKeyword,
+  TokenKind.CatchKeyword,
+  TokenKind.ClassKeyword,
+  TokenKind.ConstKeyword,
+  TokenKind.ContinueKeyword,
+  TokenKind.DebuggerKeyword,
+  TokenKind.DefaultKeyword,
+  TokenKind.DeleteKeyword,
+  TokenKind.DoKeyword,
+  TokenKind.ElseKeyword,
+  TokenKind.EnumKeyword,
+  TokenKind.ExportKeyword,
+  TokenKind.ExtendsKeyword,
+  TokenKind.FalseKeyword,
+  TokenKind.FinallyKeyword,
+  TokenKind.ForKeyword,
+  TokenKind.FunctionKeyword,
+  TokenKind.IfKeyword,
+  TokenKind.ImportKeyword,
+  TokenKind.InKeyword,
+  TokenKind.InstanceOfKeyword,
+  TokenKind.NewKeyword,
+  TokenKind.NullKeyword,
+  TokenKind.ReturnKeyword,
+  TokenKind.SuperKeyword,
+  TokenKind.SwitchKeyword,
+  TokenKind.ThisKeyword,
+  TokenKind.ThrowKeyword,
+  TokenKind.TrueKeyword,
+  TokenKind.TryKeyword,
+  TokenKind.TypeOfKeyword,
+  TokenKind.VarKeyword,
+  TokenKind.VoidKeyword,
+  TokenKind.WhileKeyword,
+  TokenKind.WithKeyword,
+  // Strict-mode / module reserved words.
+  TokenKind.LetKeyword,
+  TokenKind.StaticKeyword,
+  TokenKind.YieldKeyword,
+  TokenKind.AwaitKeyword,
+  TokenKind.ImplementsKeyword,
+  TokenKind.InterfaceKeyword,
+  TokenKind.PackageKeyword,
+  TokenKind.PrivateKeyword,
+  TokenKind.ProtectedKeyword,
+  TokenKind.PublicKeyword,
+]);
+
+/** True when the scanner token may be used as an identifier/binding name. */
+export function isIdentifierNameToken(kind: TokenKind): boolean {
+  return kind === TokenKind.Identifier || (isKeywordKind(kind) && !RESERVED_KEYWORDS.has(kind));
+}

package/src/parser/context.ts

@@ -10,7 +10,7 @@
 import { DiagnosticBag, DiagnosticCode } from "../diagnostics/diagnostic.js";
 import type { SourceFile } from "../diagnostics/source.js";
 import { Scanner } from "../lexer/scanner.js";
-import { Token, TokenKind } from "../lexer/token.js";
+import { isIdentifierNameToken, isKeywordKind, Token, TokenKind } from "../lexer/token.js";
 import { SyntaxKind } from "../ast/kinds.js";
 import type { Identifier, StringLiteral } from "../ast/nodes.js";
 import { SpeculationError } from "./speculation.js";
@@ -121,24 +121,13 @@ export class ParserContext {
   }
 
   isIdentifierLike(token: Token): boolean {
-    if (token.kind === TokenKind.Identifier) return true;
-    switch (token.kind) {
-      case TokenKind.AsKeyword:
-      case TokenKind.SatisfiesKeyword:
-      case TokenKind.FromKeyword:
-      case TokenKind.TypeKeyword:
-      case TokenKind.GetKeyword:
-      case TokenKind.SetKeyword:
-      case TokenKind.AsyncKeyword:
-        return true;
-      default:
-        return false;
-    }
+    return isIdentifierNameToken(token.kind);
   }
 
   parseIdentifier(allowKeywords = false): Identifier {
     const token = this.token;
-    if (token.kind === TokenKind.Identifier || (allowKeywords && this.isIdentifierLike(token))) {
+    const ok = allowKeywords ? isKeywordKind(token.kind) : isIdentifierNameToken(token.kind);
+    if (token.kind === TokenKind.Identifier || ok) {
       this.nextToken();
       return { kind: SyntaxKind.Identifier, text: token.text, start: token.start, end: token.end };
     }

package/src/parser/declarations.ts

@@ -37,6 +37,7 @@ import {
   type TypeParameterDeclaration,
 } from "../ast/nodes.js";
 import { expressionToPropertyName } from "./helpers.js";
+import { SpeculationError } from "./speculation.js";
 import type { Parser } from "./parser.js";
 
 export interface DeclarationMethods {
@@ -44,6 +45,8 @@ export interface DeclarationMethods {
   parseTypeParameters(this: Parser): TypeParameterDeclaration[];
   parseGreaterThan(this: Parser): void;
   parseParameters(this: Parser): Parameter[];
+  parseBindingName(this: Parser): import("../ast/declarations.js").BindingName;
+  parseBindingElement(this: Parser, allowPropertyName: boolean): import("../ast/declarations.js").BindingElement;
   parseReturnType(this: Parser): TypeNode;
   parseClassDeclaration(this: Parser, modifiers: Modifier[]): ClassDeclaration;
   parseHeritageClauses(this: Parser): HeritageClause[];
@@ -153,7 +156,15 @@ export const declarationMethods: DeclarationMethods = {
         this.nextToken();
         dotDotDotToken = true;
       }
-      const name = this.parseIdentifier();
+      let name: import("../ast/declarations.js").BindingName;
+      let isThisParameter = false;
+      if (this.at(TokenKind.ThisKeyword)) {
+        const thisToken = this.nextToken();
+        name = { kind: SyntaxKind.Identifier, text: "this", start: thisToken.start, end: thisToken.end };
+        isThisParameter = true;
+      } else {
+        name = this.parseBindingName();
+      }
       let questionToken = false;
       if (this.at(TokenKind.Question)) {
         this.nextToken();
@@ -169,7 +180,11 @@ export const declarationMethods: DeclarationMethods = {
         this.nextToken();
         initializer = this.parseAssignmentExpression();
       }
-      params.push({ kind: SyntaxKind.Parameter, name, modifiers, dotDotDotToken, questionToken, type, initializer, start, end: initializer?.end ?? type?.end ?? name.end });
+      // A `this` parameter is a type-level annotation only and is never a
+      // runtime argument, so it must not occupy an `argv` slot.
+      if (!isThisParameter) {
+        params.push({ kind: SyntaxKind.Parameter, name, modifiers, dotDotDotToken, questionToken, type, initializer, start, end: initializer?.end ?? type?.end ?? name.end });
+      }
       if (this.at(TokenKind.Comma)) this.nextToken();
       else break;
     }
@@ -177,6 +192,76 @@ export const declarationMethods: DeclarationMethods = {
     return params;
   },
 
+  parseBindingName(this: Parser): import("../ast/declarations.js").BindingName {
+    if (this.at(TokenKind.OpenBracket)) {
+      const open = this.nextToken();
+      const elements: (import("../ast/declarations.js").BindingElement | undefined)[] = [];
+      while (!this.at(TokenKind.CloseBracket) && !this.at(TokenKind.EndOfFile)) {
+        if (this.at(TokenKind.Comma)) {
+          elements.push(undefined);
+          this.nextToken();
+          continue;
+        }
+        elements.push(this.parseBindingElement(false));
+        if (this.at(TokenKind.Comma)) this.nextToken();
+        else break;
+      }
+      const close = this.parseExpected(TokenKind.CloseBracket);
+      return { kind: SyntaxKind.ArrayBindingPattern, elements, start: open.start, end: close.end };
+    }
+    if (this.at(TokenKind.OpenBrace)) {
+      const open = this.nextToken();
+      const elements: import("../ast/declarations.js").BindingElement[] = [];
+      while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+        elements.push(this.parseBindingElement(true));
+        if (this.at(TokenKind.Comma)) this.nextToken();
+        else break;
+      }
+      const close = this.parseExpected(TokenKind.CloseBrace);
+      return { kind: SyntaxKind.ObjectBindingPattern, elements, start: open.start, end: close.end };
+    }
+    return this.parseIdentifier();
+  },
+
+  parseBindingElement(this: Parser, allowPropertyName: boolean): import("../ast/declarations.js").BindingElement {
+    const start = this.token.start;
+    let dotDotDotToken = false;
+    if (this.at(TokenKind.DotDotDot)) {
+      this.nextToken();
+      dotDotDotToken = true;
+    }
+    let propertyName: PropertyName | undefined;
+    let name: import("../ast/declarations.js").BindingName;
+    if (allowPropertyName && this.at(TokenKind.OpenBracket)) {
+      // Computed property key: `{ [expr]: target }`.
+      this.nextToken();
+      const expr = this.parseAssignmentExpression();
+      this.parseExpected(TokenKind.CloseBracket);
+      propertyName = expressionToPropertyName(expr) ?? { kind: SyntaxKind.Identifier, text: "<computed>", start: expr.start, end: expr.end };
+      this.parseExpected(TokenKind.Colon);
+      name = this.parseBindingName();
+    } else if (allowPropertyName && !this.at(TokenKind.OpenBrace) && !this.at(TokenKind.OpenBracket)) {
+      const first = this.parseIdentifierName();
+      if (this.at(TokenKind.Colon)) {
+        this.nextToken();
+        propertyName = first;
+        name = this.parseBindingName();
+      } else {
+        name = first;
+      }
+    } else {
+      // Array element, or a nested pattern used as an object value.
+      name = this.parseBindingName();
+    }
+    let initializer: Expression | undefined;
+    if (this.at(TokenKind.Equals)) {
+      this.nextToken();
+      initializer = this.parseAssignmentExpression();
+    }
+    const end = initializer?.end ?? (name.kind === SyntaxKind.Identifier ? name.end : name.end);
+    return { kind: SyntaxKind.BindingElement, name, propertyName, dotDotDotToken, initializer, start, end };
+  },
+
   parseReturnType(this: Parser): TypeNode {
     if (this.at(TokenKind.AssertsKeyword)) {
       const start = this.nextToken().start;
@@ -249,6 +334,42 @@ export const declarationMethods: DeclarationMethods = {
       this.nextToken();
       return undefined;
     }
+    if (
+      (this.at(TokenKind.GetKeyword) || this.at(TokenKind.SetKeyword)) &&
+      !this.atAhead(1, TokenKind.OpenParen) &&
+      !this.atAhead(1, TokenKind.Colon) &&
+      !this.atAhead(1, TokenKind.Equals) &&
+      !this.atAhead(1, TokenKind.Question) &&
+      !this.atAhead(1, TokenKind.LessThan) &&
+      !this.atAhead(1, TokenKind.Semicolon)
+    ) {
+      const accessorToken = this.nextToken();
+      const name = this.parsePropertyName();
+      const parameters = this.parseParameters();
+      let returnType: TypeNode | undefined;
+      if (this.at(TokenKind.Colon)) {
+        this.nextToken();
+        returnType = this.parseReturnType();
+      }
+      let body: Block | undefined;
+      if (this.at(TokenKind.OpenBrace)) body = this.parseBlock();
+      else this.parseSemicolon();
+      const accessor: MethodDeclaration = {
+        kind: SyntaxKind.MethodDeclaration,
+        name,
+        modifiers,
+        typeParameters: [],
+        parameters,
+        returnType,
+        body,
+        flags: NodeFlags.None,
+        optional: false,
+        accessor: accessorToken.kind === TokenKind.GetKeyword ? "get" : "set",
+        start,
+        end: body?.end ?? returnType?.end ?? name.end,
+      };
+      return accessor;
+    }
     if (this.at(TokenKind.ConstructorKeyword)) {
       const name = this.nextToken();
       const parameters = this.parseParameters();
@@ -337,13 +458,10 @@ export const declarationMethods: DeclarationMethods = {
       return { kind: SyntaxKind.NumericLiteral, text: token.text, value: Number(token.value ?? 0), start: token.start, end: token.end };
     }
     if (token.kind === TokenKind.OpenBracket) {
-      this.nextToken();
+      const start = this.nextToken().start;
       const expr = this.parseAssignmentExpression();
-      this.parseExpected(TokenKind.CloseBracket);
-      const name = expressionToPropertyName(expr);
-      if (name) return name;
-      this.error(DiagnosticCode.InvalidTypeSyntax, "Computed property names are not supported by xbintsc");
-      return { kind: SyntaxKind.Identifier, text: "<computed>", start: expr.start, end: expr.end };
+      const close = this.parseExpected(TokenKind.CloseBracket);
+      return { kind: SyntaxKind.ComputedPropertyName, expression: expr, start, end: close.end };
     }
     return this.parseIdentifierName();
   },
@@ -439,34 +557,27 @@ export const declarationMethods: DeclarationMethods = {
       const name: Identifier = { kind: SyntaxKind.Identifier, text: "__call", start, end: start };
       return { kind: SyntaxKind.MethodSignature, name, questionToken: false, typeParameters, parameters, returnType, start, end: returnType?.end ?? start };
     }
-    if (this.at(TokenKind.OpenBracket) && this.atAhead(1, TokenKind.Identifier)) {
-      const saveIndex = this.index;
-      const savePos = this.scanner.position;
-      const savedTokens = this.tokens.slice();
-      this.nextToken();
-      const parameters: Parameter[] = [];
-      let ok = true;
-      try {
+    if (this.at(TokenKind.OpenBracket)) {
+      const indexSignature = this.tryParse<TypeElement>(() => {
+        const open = this.nextToken();
+        const parameters: Parameter[] = [];
         const paramName = this.parseIdentifier();
-        let type: TypeNode | undefined;
+        let paramType: TypeNode | undefined;
         if (this.at(TokenKind.Colon)) {
           this.nextToken();
-          type = this.parseType();
-        } else ok = false;
+          paramType = this.parseType();
+        } else {
+          throw new SpeculationError();
+        }
         this.parseExpected(TokenKind.CloseBracket);
-        parameters.push({ kind: SyntaxKind.Parameter, name: paramName, modifiers: [], dotDotDotToken: false, questionToken: false, type, start: paramName.start, end: type?.end ?? paramName.end });
-      } catch {
-        ok = false;
-      }
-      if (ok && this.at(TokenKind.Colon)) {
+        if (!this.at(TokenKind.Colon)) throw new SpeculationError();
         this.nextToken();
         const type = this.parseType();
         this.parseSemicolonOrComma();
-        return { kind: SyntaxKind.IndexSignature, parameters, type, start, end: type.end };
-      }
-      this.index = saveIndex;
-      this.tokens = savedTokens;
-      this.scanner.seek(savePos);
+        parameters.push({ kind: SyntaxKind.Parameter, name: paramName, modifiers: [], dotDotDotToken: false, questionToken: false, type: paramType, start: paramName.start, end: paramType?.end ?? paramName.end });
+        return { kind: SyntaxKind.IndexSignature, parameters, type, start: open.start, end: type.end };
+      });
+      if (indexSignature) return indexSignature;
     }
     const name = this.parsePropertyName();
     let questionToken = false;

package/src/parser/expressions.ts

@@ -180,9 +180,11 @@ export const expressionMethods: ExpressionMethods = {
       const t = this.lookAhead(i);
       if (t.kind === TokenKind.EndOfFile) return -1;
       if (t.kind === TokenKind.OpenParen || t.kind === TokenKind.OpenBracket || t.kind === TokenKind.OpenBrace) depth++;
-      else if (t.kind === TokenKind.CloseParen || t.kind === TokenKind.CloseBracket || t.kind === TokenKind.CloseBrace) depth--;
-      else if (t.kind === TokenKind.EqualsGreaterThan && depth === 0) return i;
-      else if (t.kind === TokenKind.Semicolon && depth === 0) return -1;
+      else if (t.kind === TokenKind.CloseParen || t.kind === TokenKind.CloseBracket || t.kind === TokenKind.CloseBrace) {
+        if (depth === 0) return -1;
+        depth--;
+      } else if (t.kind === TokenKind.EqualsGreaterThan && depth === 0) return i;
+      else if (depth === 0 && (t.kind === TokenKind.Semicolon || t.kind === TokenKind.Comma)) return -1;
     }
   },
 
@@ -329,7 +331,7 @@ export const expressionMethods: ExpressionMethods = {
       }
       case TokenKind.BigIntLiteral:
         this.nextToken();
-        return { kind: SyntaxKind.BigIntLiteral, text: token.text, value: BigInt(token.value ?? 0n), start: token.start, end: token.end };
+        return { kind: SyntaxKind.BigIntLiteral, text: token.text, value: Number(token.value ?? 0), start: token.start, end: token.end };
       case TokenKind.StringLiteral:
         this.nextToken();
         return this.stringLiteralFromToken(token);
@@ -374,7 +376,16 @@ export const expressionMethods: ExpressionMethods = {
       case TokenKind.NoSubstitutionTemplateLiteral:
         return this.parseTemplateLiteral();
       case TokenKind.Slash:
+      case TokenKind.RegularExpressionLiteral:
         return this.parseRegularExpression();
+      case TokenKind.ImportKeyword:
+        if (this.atAhead(1, TokenKind.Dot)) {
+          const importToken = this.nextToken();
+          this.nextToken();
+          const metaName = this.parseIdentifierName();
+          return { kind: SyntaxKind.Identifier, text: "import.meta", start: importToken.start, end: metaName.end };
+        }
+        break;
       default:
         break;
     }
@@ -422,6 +433,11 @@ export const expressionMethods: ExpressionMethods = {
         expression = { kind: SyntaxKind.TaggedTemplateExpression, tag: expression, template, start: expression.start, end: template.end };
         continue;
       }
+      if (token.kind === TokenKind.Exclamation && !token.precededByLineBreak) {
+        this.nextToken();
+        expression = { kind: SyntaxKind.NonNullExpression, expression, start: expression.start, end: token.end };
+        continue;
+      }
       return expression;
     }
   },

package/src/parser/helpers.ts

@@ -13,6 +13,8 @@ export function expressionToPropertyName(expr: Expression): PropertyName | undef
       return expr;
     case SyntaxKind.Identifier:
       return expr;
+    case SyntaxKind.PropertyAccessExpression:
+      return expr.name;
     default:
       return undefined;
   }

package/src/parser/modules.ts

@@ -126,6 +126,11 @@ export const moduleMethods: ModuleMethods = {
       const assignment: ExportAssignment = { kind: SyntaxKind.ExportAssignment, isExportEquals: false, expression, start, end: expression.end };
       return assignment;
     }
+    let isTypeOnly = false;
+    if (this.at(TokenKind.TypeKeyword) && (this.atAhead(1, TokenKind.OpenBrace) || this.atAhead(1, TokenKind.Asterisk))) {
+      isTypeOnly = true;
+      this.nextToken();
+    }
     if (this.at(TokenKind.Asterisk)) {
       this.nextToken();
       let nsName: Identifier | undefined;
@@ -144,7 +149,7 @@ export const moduleMethods: ModuleMethods = {
         modifiers: [],
         exportClause: nsName ? { kind: SyntaxKind.NamespaceImport, name: nsName, start: nsName.start, end: nsName.end } : undefined,
         moduleSpecifier,
-        isTypeOnly: false,
+        isTypeOnly,
         start,
         end: moduleSpecifier?.end ?? nsName?.end ?? start,
       };
@@ -158,7 +163,7 @@ export const moduleMethods: ModuleMethods = {
         if (this.at(TokenKind.StringLiteral)) moduleSpecifier = this.stringLiteralFromToken(this.nextToken());
       }
       this.parseSemicolon();
-      const decl: ExportDeclaration = { kind: SyntaxKind.ExportDeclaration, modifiers: [], exportClause: namedExports, moduleSpecifier, isTypeOnly: false, start, end: moduleSpecifier?.end ?? namedExports.end };
+      const decl: ExportDeclaration = { kind: SyntaxKind.ExportDeclaration, modifiers: [], exportClause: namedExports, moduleSpecifier, isTypeOnly, start, end: moduleSpecifier?.end ?? namedExports.end };
       return decl;
     }
     const modifiers = this.tryParseModifiers();

package/src/parser/statements.ts

@@ -4,7 +4,7 @@
  */
 
 import { DiagnosticCode } from "../diagnostics/diagnostic.js";
-import { isOfKeyword, TokenKind } from "../lexer/token.js";
+import { isIdentifierNameToken, isKeywordKind, isOfKeyword, TokenKind } from "../lexer/token.js";
 import {
   ModifierKind,
   SyntaxKind,
@@ -58,6 +58,15 @@ export const statementMethods: StatementMethods = {
     const modifiers: Modifier[] = [];
     for (;;) {
       const kind = this.token.kind;
+      const nextKind = this.lookAhead(1).kind;
+      const nextStartsName =
+        isIdentifierNameToken(nextKind) ||
+        isKeywordKind(nextKind) ||
+        nextKind === TokenKind.OpenBracket ||
+        nextKind === TokenKind.StringLiteral ||
+        nextKind === TokenKind.NumericLiteral ||
+        nextKind === TokenKind.Asterisk ||
+        nextKind === TokenKind.OpenBrace;
       let modifierKind: ModifierKind | undefined;
       switch (kind) {
         case TokenKind.ExportKeyword:
@@ -89,6 +98,9 @@ export const statementMethods: StatementMethods = {
         case TokenKind.ReadonlyKeyword:
           modifierKind = ModifierKind.Readonly;
           break;
+        case TokenKind.ConstKeyword:
+          if (this.atAhead(1, TokenKind.EnumKeyword)) modifierKind = ModifierKind.Const;
+          break;
         case TokenKind.AsyncKeyword:
           if (!this.lookAhead(1).precededByLineBreak) modifierKind = ModifierKind.Async;
           break;
@@ -96,6 +108,10 @@ export const statementMethods: StatementMethods = {
           break;
       }
       if (!modifierKind) break;
+      // Contextual modifiers (`declare`, `readonly`, `static`, …) are only
+      // modifiers when a member/declaration name follows; otherwise they are
+      // names themselves (`private declare(...)`, `readonly()`).
+      if (modifierKind !== ModifierKind.Export && modifierKind !== ModifierKind.Default && !nextStartsName) break;
       const token = this.nextToken();
       modifiers.push({ kind: SyntaxKind.Unknown, modifierKind, start: token.start, end: token.end });
     }
@@ -120,6 +136,10 @@ export const statementMethods: StatementMethods = {
       case TokenKind.VarKeyword:
       case TokenKind.LetKeyword:
       case TokenKind.ConstKeyword:
+        if (this.at(TokenKind.ConstKeyword) && this.atAhead(1, TokenKind.EnumKeyword)) {
+          const constToken = this.nextToken();
+          return this.parseEnumDeclaration([{ kind: SyntaxKind.Unknown, modifierKind: ModifierKind.Const, start: constToken.start, end: constToken.end }]);
+        }
         return this.parseVariableStatement([]);
       case TokenKind.FunctionKeyword:
         return this.parseFunctionDeclaration([]);
@@ -186,6 +206,10 @@ export const statementMethods: StatementMethods = {
       case TokenKind.VarKeyword:
       case TokenKind.LetKeyword:
       case TokenKind.ConstKeyword:
+        if (this.at(TokenKind.ConstKeyword) && this.atAhead(1, TokenKind.EnumKeyword)) {
+          const constToken = this.nextToken();
+          return this.parseEnumDeclaration([...modifiers, { kind: SyntaxKind.Unknown, modifierKind: ModifierKind.Const, start: constToken.start, end: constToken.end }]);
+        }
         return this.parseVariableStatement(modifiers);
       case TokenKind.FunctionKeyword:
         return this.parseFunctionDeclaration(modifiers);
@@ -244,9 +268,9 @@ export const statementMethods: StatementMethods = {
   },
 
   parseVariableDeclaration(this: Parser): VariableDeclaration {
-    const name = this.parseIdentifier();
+    const name = this.parseBindingName();
     let exclamation = false;
-    if (this.at(TokenKind.Exclamation)) {
+    if (name.kind === SyntaxKind.Identifier && this.at(TokenKind.Exclamation)) {
       this.nextToken();
       exclamation = true;
     }

package/src/parser/types.ts

@@ -243,6 +243,11 @@ export const typeMethods: TypeMethods = {
         const literal: NumericLiteral = { kind: SyntaxKind.NumericLiteral, text: `-${num.text}`, value: -Number(num.value ?? 0), start, end: num.end };
         return { kind: SyntaxKind.LiteralType, literal, start, end: num.end };
       }
+      case TokenKind.ConstKeyword: {
+        // `as const` const assertion: erased like any other type.
+        this.nextToken();
+        return { kind: SyntaxKind.AnyKeywordType, start, end: token.end };
+      }
       case TokenKind.ImportKeyword: {
         // import("...").T - parse loosely and degrade to `any`.
         this.nextToken();