xbintsc 0.1.6 → 0.1.9

package/src/parser/literals.ts

@@ -0,0 +1,207 @@
+/**
+ * Literal and "primary aggregate" expression parsing: array/object literals,
+ * function/class expressions, template literals and regular expression
+ * literals.
+ */
+
+import { DiagnosticCode } from "../diagnostics/diagnostic.js";
+import { TokenKind } from "../lexer/token.js";
+import {
+  NodeFlags,
+  SyntaxKind,
+  type ArrayLiteralExpression,
+  type ClassExpression,
+  type Expression,
+  type FunctionExpression,
+  type Identifier,
+  type ObjectLiteralElementLike,
+  type ObjectLiteralExpression,
+  type RegularExpressionLiteral,
+  type ShorthandPropertyAssignment,
+  type TemplateLiteral,
+  type TemplateSpan,
+  type TypeNode,
+} from "../ast/nodes.js";
+import type { Parser } from "./parser.js";
+
+export interface LiteralMethods {
+  parseArrayLiteral(this: Parser): ArrayLiteralExpression;
+  parseObjectLiteral(this: Parser): ObjectLiteralExpression;
+  parseFunctionExpression(this: Parser): FunctionExpression;
+  parseClassExpression(this: Parser): ClassExpression;
+  parseTemplateLiteral(this: Parser): TemplateLiteral;
+  parseRegularExpression(this: Parser): RegularExpressionLiteral;
+}
+
+export const literalMethods: LiteralMethods = {
+  parseArrayLiteral(this: Parser): ArrayLiteralExpression {
+    const open = this.parseExpected(TokenKind.OpenBracket);
+    const elements: Expression[] = [];
+    while (!this.at(TokenKind.CloseBracket) && !this.at(TokenKind.EndOfFile)) {
+      if (this.at(TokenKind.Comma)) {
+        // Elision: represent as an undefined literal hole.
+        elements.push({ kind: SyntaxKind.UndefinedKeyword, start: this.token.start, end: this.token.start });
+        this.nextToken();
+        continue;
+      }
+      if (this.at(TokenKind.DotDotDot)) {
+        const start = this.nextToken().start;
+        const expression = this.parseAssignmentExpression();
+        elements.push({ kind: SyntaxKind.SpreadElement, expression, start, end: expression.end });
+      } else {
+        elements.push(this.parseAssignmentExpression());
+      }
+      if (this.at(TokenKind.Comma)) this.nextToken();
+      else break;
+    }
+    const close = this.parseExpected(TokenKind.CloseBracket);
+    return { kind: SyntaxKind.ArrayLiteralExpression, elements, start: open.start, end: close.end };
+  },
+
+  parseObjectLiteral(this: Parser): ObjectLiteralExpression {
+    const open = this.parseExpected(TokenKind.OpenBrace);
+    const properties: ObjectLiteralElementLike[] = [];
+    while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+      if (this.at(TokenKind.DotDotDot)) {
+        const start = this.nextToken().start;
+        const expression = this.parseAssignmentExpression();
+        properties.push({ kind: SyntaxKind.SpreadElement, expression, start, end: expression.end });
+      } else {
+        const start = this.token.start;
+        const name = this.parsePropertyName();
+        if (this.at(TokenKind.Colon)) {
+          this.nextToken();
+          const initializer = this.parseAssignmentExpression();
+          properties.push({ kind: SyntaxKind.PropertyAssignment, name, initializer, start, end: initializer.end });
+        } else if (this.at(TokenKind.OpenParen) || this.at(TokenKind.LessThan)) {
+          const typeParameters = this.at(TokenKind.LessThan) ? this.parseTypeParameters() : [];
+          const parameters = this.parseParameters();
+          let returnType: TypeNode | undefined;
+          if (this.at(TokenKind.Colon)) {
+            this.nextToken();
+            returnType = this.parseReturnType();
+          }
+          const body = this.parseBlock();
+          const fn: FunctionExpression = { kind: SyntaxKind.FunctionExpression, typeParameters, parameters, returnType, body, flags: NodeFlags.None, start, end: body.end };
+          properties.push({ kind: SyntaxKind.PropertyAssignment, name, initializer: fn, start, end: body.end });
+        } else if (name.kind === SyntaxKind.Identifier) {
+          const shorthand: ShorthandPropertyAssignment = { kind: SyntaxKind.ShorthandPropertyAssignment, name, start, end: name.end };
+          properties.push(shorthand);
+        } else {
+          this.error(DiagnosticCode.UnexpectedToken, "Invalid object literal member");
+          this.nextToken();
+        }
+      }
+      if (this.at(TokenKind.Comma)) this.nextToken();
+      else break;
+    }
+    const close = this.parseExpected(TokenKind.CloseBrace);
+    return { kind: SyntaxKind.ObjectLiteralExpression, properties, start: open.start, end: close.end };
+  },
+
+  parseFunctionExpression(this: Parser): FunctionExpression {
+    const start = this.parseExpected(TokenKind.FunctionKeyword).start;
+    let flags = NodeFlags.None;
+    if (this.at(TokenKind.Asterisk)) {
+      this.nextToken();
+      flags |= NodeFlags.Generator;
+    }
+    let name: Identifier | undefined;
+    if (this.at(TokenKind.Identifier)) name = this.parseIdentifier();
+    const typeParameters = this.parseTypeParameters();
+    const parameters = this.parseParameters();
+    let returnType: TypeNode | undefined;
+    if (this.at(TokenKind.Colon)) {
+      this.nextToken();
+      returnType = this.parseReturnType();
+    }
+    const body = this.parseBlock();
+    return { kind: SyntaxKind.FunctionExpression, name, typeParameters, parameters, returnType, body, flags, start, end: body.end };
+  },
+
+  parseClassExpression(this: Parser): ClassExpression {
+    const start = this.parseExpected(TokenKind.ClassKeyword).start;
+    let name: Identifier | undefined;
+    if (this.at(TokenKind.Identifier)) name = this.parseIdentifier();
+    const typeParameters = this.parseTypeParameters();
+    const heritage = this.parseHeritageClauses();
+    const members = this.parseClassMembers();
+    return { kind: SyntaxKind.ClassExpression, name, typeParameters, heritage, members, start, end: members[members.length - 1]?.end ?? start };
+  },
+
+  parseTemplateLiteral(this: Parser): TemplateLiteral {
+    const startToken = this.token;
+    if (startToken.kind === TokenKind.NoSubstitutionTemplateLiteral) {
+      this.nextToken();
+      return { kind: SyntaxKind.NoSubstitutionTemplateLiteral, text: startToken.text, value: String(startToken.value ?? ""), start: startToken.start, end: startToken.end } as unknown as TemplateLiteral;
+    }
+    if (startToken.kind === TokenKind.Backtick) {
+      // Re-scan from the backtick so the scanner produces a TemplateHead.
+      this.scanner.seek(startToken.start);
+      this.tokens = [this.scanner.nextToken()];
+      this.index = 0;
+      return this.parseTemplateLiteral();
+    }    const head = String(startToken.value ?? "");
+    this.nextToken();
+    const spans: TemplateSpan[] = [];
+    for (;;) {
+      const expression = this.parseExpression();
+      if (!this.at(TokenKind.CloseBrace)) {
+        this.error(DiagnosticCode.UnterminatedTemplate, "Expected '}' to close template substitution");
+        return { kind: SyntaxKind.TemplateLiteral, head, spans, start: startToken.start, end: this.token.end };
+      }
+      // The `}` terminates a substitution; re-read it as template text without
+      // first scanning the following (template) characters as normal tokens.
+      const closeStart = this.token.start;
+      this.tokens = [this.scanner.continueTemplate(closeStart)];
+      this.index = 0;
+      const literalToken = this.token;
+      if (literalToken.kind === TokenKind.NoSubstitutionTemplateLiteral) {
+        this.nextToken();
+        spans.push({ kind: SyntaxKind.TemplateSpan, expression, literal: String(literalToken.value ?? ""), isTail: true, start: expression.start, end: literalToken.end });
+        return { kind: SyntaxKind.TemplateLiteral, head, spans, start: startToken.start, end: literalToken.end };
+      }
+      if (literalToken.kind === TokenKind.TemplateHead) {
+        this.nextToken();
+        spans.push({ kind: SyntaxKind.TemplateSpan, expression, literal: String(literalToken.value ?? ""), isTail: false, start: expression.start, end: literalToken.end });
+        continue;
+      }
+      this.error(DiagnosticCode.UnterminatedTemplate, "Unterminated template literal", literalToken);
+      return { kind: SyntaxKind.TemplateLiteral, head, spans, start: startToken.start, end: literalToken.end };
+    }
+  },
+
+  parseRegularExpression(this: Parser): RegularExpressionLiteral {
+    const token = this.token;
+    const text = this.source.text;
+    let i = token.start + 1;
+    let inClass = false;
+    let pattern = "";
+    for (; i < text.length; i++) {
+      const ch = text[i]!;
+      if (ch === "\\") {
+        pattern += ch + (text[i + 1] ?? "");
+        i++;
+        continue;
+      }
+      if (ch === "[") inClass = true;
+      else if (ch === "]") inClass = false;
+      else if (ch === "/" && !inClass) break;
+      else if (ch === "\n") break;
+      pattern += ch;
+    }
+    if (text[i] !== "/") {
+      this.error(DiagnosticCode.InvalidCharacter, "Unterminated regular expression");
+      this.nextToken();
+      return { kind: SyntaxKind.RegularExpressionLiteral, text: token.text, pattern: "", flags: "", start: token.start, end: token.end };
+    }
+    i++;
+    const flagsStart = i;
+    while (i < text.length && /[a-z]/i.test(text[i]!)) i++;
+    const flags = text.slice(flagsStart, i);
+    this.scanner.seek(i);
+    this.tokens = [this.scanner.nextToken()];
+    this.index = 0;
+    return { kind: SyntaxKind.RegularExpressionLiteral, text: text.slice(token.start, i), pattern, flags, start: token.start, end: i };
+  },
+};

package/src/parser/modules.ts

@@ -0,0 +1,194 @@
+/**
+ * Import and export declaration parsing.
+ */
+
+import { TokenKind } from "../lexer/token.js";
+import {
+  ModifierKind,
+  SyntaxKind,
+  type ExportAssignment,
+  type ExportDeclaration,
+  type ExportSpecifier,
+  type Identifier,
+  type ImportClause,
+  type ImportDeclaration,
+  type ImportSpecifier,
+  type Modifier,
+  type NamedExports,
+  type NamedImports,
+  type NamespaceImport,
+  type Statement,
+  type StringLiteral,
+} from "../ast/nodes.js";
+import { propertyNameText } from "./helpers.js";
+import type { Parser } from "./parser.js";
+
+export interface ModuleMethods {
+  parseImportDeclaration(this: Parser): ImportDeclaration;
+  parseNamedImports(this: Parser): NamedImports;
+  parseExportDeclaration(this: Parser): Statement;
+  parseNamedExports(this: Parser): NamedExports;
+}
+
+export const moduleMethods: ModuleMethods = {
+  parseImportDeclaration(this: Parser): ImportDeclaration {
+    const start = this.parseExpected(TokenKind.ImportKeyword).start;
+    let importClause: ImportClause | undefined;
+    if (!this.at(TokenKind.StringLiteral)) {
+      const clauseStart = this.token.start;
+      let isTypeOnly = false;
+      if (this.at(TokenKind.TypeKeyword) && !this.lookAhead(1).precededByLineBreak) {
+        const next = this.lookAhead(1);
+        if (this.isIdentifierLike(next) || next.kind === TokenKind.OpenBrace || next.kind === TokenKind.Asterisk) {
+          this.nextToken();
+          isTypeOnly = true;
+        }
+      }
+      let name: Identifier | undefined;
+      let namedBindings: NamedImports | NamespaceImport | undefined;
+      if (this.isIdentifierLike(this.token)) {
+        name = this.parseIdentifierName();
+        if (this.at(TokenKind.Comma)) this.nextToken();
+      }
+      if (this.at(TokenKind.Asterisk)) {
+        this.nextToken();
+        this.parseExpected(TokenKind.AsKeyword);
+        const nsName = this.parseIdentifier();
+        namedBindings = { kind: SyntaxKind.NamespaceImport, name: nsName, start: nsName.start, end: nsName.end };
+      } else if (this.at(TokenKind.OpenBrace)) {
+        namedBindings = this.parseNamedImports();
+      }
+      importClause = { kind: SyntaxKind.ImportClause, name, namedBindings, isTypeOnly, start: clauseStart, end: namedBindings?.end ?? name?.end ?? clauseStart };
+    }
+    this.parseExpected(TokenKind.FromKeyword);
+    const moduleToken = this.parseExpected(TokenKind.StringLiteral);
+    const moduleSpecifier = this.stringLiteralFromToken(moduleToken);
+    const attributes: { name: string; value: string }[] = [];
+    if (this.at(TokenKind.WithKeyword) || (this.at(TokenKind.Identifier) && this.token.text === "assert")) {
+      this.nextToken();
+      this.parseExpected(TokenKind.OpenBrace);
+      while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+        const key = this.parsePropertyName();
+        this.parseExpected(TokenKind.Colon);
+        const valueToken = this.parseExpected(TokenKind.StringLiteral);
+        attributes.push({ name: propertyNameText(key), value: String(valueToken.value ?? "") });
+        if (this.at(TokenKind.Comma)) this.nextToken();
+        else break;
+      }
+      this.parseExpected(TokenKind.CloseBrace);
+    }
+    this.parseSemicolon();
+    return { kind: SyntaxKind.ImportDeclaration, importClause, moduleSpecifier, attributes, start, end: moduleSpecifier.end };
+  },
+
+  parseNamedImports(this: Parser): NamedImports {
+    const open = this.parseExpected(TokenKind.OpenBrace);
+    const elements: ImportSpecifier[] = [];
+    while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+      const specStart = this.token.start;
+      let isTypeOnly = false;
+      if (this.at(TokenKind.TypeKeyword)) {
+        this.nextToken();
+        isTypeOnly = true;
+      }
+      const first = this.parseIdentifierName();
+      let propertyName: Identifier | undefined;
+      let name = first;
+      if (this.at(TokenKind.AsKeyword)) {
+        this.nextToken();
+        propertyName = first;
+        name = this.parseIdentifierName();
+      }
+      elements.push({ kind: SyntaxKind.ImportSpecifier, propertyName, name, isTypeOnly, start: specStart, end: name.end });
+      if (this.at(TokenKind.Comma)) this.nextToken();
+      else break;
+    }
+    const close = this.parseExpected(TokenKind.CloseBrace);
+    return { kind: SyntaxKind.NamedImports, elements, start: open.start, end: close.end };
+  },
+
+  parseExportDeclaration(this: Parser): Statement {
+    const start = this.parseExpected(TokenKind.ExportKeyword).start;
+    if (this.at(TokenKind.Equals)) {
+      this.nextToken();
+      const expression = this.parseExpression();
+      this.parseSemicolon();
+      const assignment: ExportAssignment = { kind: SyntaxKind.ExportAssignment, isExportEquals: true, expression, start, end: expression.end };
+      return assignment;
+    }
+    if (this.at(TokenKind.DefaultKeyword)) {
+      this.nextToken();
+      if (this.at(TokenKind.FunctionKeyword) || this.at(TokenKind.ClassKeyword) || this.at(TokenKind.InterfaceKeyword)) {
+        return this.parseStatementWithModifiers([{ kind: SyntaxKind.Unknown, modifierKind: ModifierKind.Default, start, end: this.token.start }]);
+      }
+      const expression = this.parseAssignmentExpression();
+      this.parseSemicolon();
+      const assignment: ExportAssignment = { kind: SyntaxKind.ExportAssignment, isExportEquals: false, expression, start, end: expression.end };
+      return assignment;
+    }
+    if (this.at(TokenKind.Asterisk)) {
+      this.nextToken();
+      let nsName: Identifier | undefined;
+      if (this.at(TokenKind.AsKeyword)) {
+        this.nextToken();
+        nsName = this.parseIdentifierName();
+      }
+      let moduleSpecifier: StringLiteral | undefined;
+      if (this.at(TokenKind.FromKeyword)) {
+        this.nextToken();
+        moduleSpecifier = this.stringLiteralFromToken(this.nextToken());
+      }
+      this.parseSemicolon();
+      const decl: ExportDeclaration = {
+        kind: SyntaxKind.ExportDeclaration,
+        modifiers: [],
+        exportClause: nsName ? { kind: SyntaxKind.NamespaceImport, name: nsName, start: nsName.start, end: nsName.end } : undefined,
+        moduleSpecifier,
+        isTypeOnly: false,
+        start,
+        end: moduleSpecifier?.end ?? nsName?.end ?? start,
+      };
+      return decl;
+    }
+    if (this.at(TokenKind.OpenBrace)) {
+      const namedExports = this.parseNamedExports();
+      let moduleSpecifier: StringLiteral | undefined;
+      if (this.at(TokenKind.FromKeyword)) {
+        this.nextToken();
+        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 };
+      return decl;
+    }
+    const modifiers = this.tryParseModifiers();
+    modifiers.push({ kind: SyntaxKind.Unknown, modifierKind: ModifierKind.Export, start, end: this.token.start });
+    return this.parseStatementWithModifiers(modifiers);
+  },
+
+  parseNamedExports(this: Parser): NamedExports {
+    const open = this.parseExpected(TokenKind.OpenBrace);
+    const elements: ExportSpecifier[] = [];
+    while (!this.at(TokenKind.CloseBrace) && !this.at(TokenKind.EndOfFile)) {
+      const specStart = this.token.start;
+      let isTypeOnly = false;
+      if (this.at(TokenKind.TypeKeyword)) {
+        this.nextToken();
+        isTypeOnly = true;
+      }
+      const first = this.parseIdentifierName();
+      let propertyName: Identifier | undefined;
+      let name = first;
+      if (this.at(TokenKind.AsKeyword)) {
+        this.nextToken();
+        propertyName = first;
+        name = this.parseIdentifierName();
+      }
+      elements.push({ kind: SyntaxKind.ExportSpecifier, propertyName, name, isTypeOnly, start: specStart, end: name.end });
+      if (this.at(TokenKind.Comma)) this.nextToken();
+      else break;
+    }
+    const close = this.parseExpected(TokenKind.CloseBrace);
+    return { kind: SyntaxKind.NamedExports, elements, start: open.start, end: close.end };
+  },
+};

package/src/parser/operators.ts

@@ -0,0 +1,181 @@
+/**
+ * Maps lexer token kinds to the AST operator enums and assigns the appropriate
+ * precedence to binary operators.
+ */
+
+import { TokenKind } from "../lexer/token.js";
+import {
+  AssignmentOperator,
+  BinaryOperator,
+  PrefixUnaryOperator,
+} from "../ast/operators.js";
+
+/** `as` / `satisfies` share the relational precedence level. */
+export const AS_PRECEDENCE = 8;
+
+export function assignmentOperator(kind: TokenKind): AssignmentOperator | undefined {
+  switch (kind) {
+    case TokenKind.Equals:
+      return AssignmentOperator.Assign;
+    case TokenKind.PlusEquals:
+      return AssignmentOperator.AddAssign;
+    case TokenKind.MinusEquals:
+      return AssignmentOperator.SubtractAssign;
+    case TokenKind.AsteriskEquals:
+      return AssignmentOperator.MultiplyAssign;
+    case TokenKind.SlashEquals:
+      return AssignmentOperator.DivideAssign;
+    case TokenKind.PercentEquals:
+      return AssignmentOperator.RemainderAssign;
+    case TokenKind.AsteriskAsteriskEquals:
+      return AssignmentOperator.ExponentAssign;
+    case TokenKind.LessThanLessThanEquals:
+      return AssignmentOperator.LessThanLessThanAssign;
+    case TokenKind.GreaterThanGreaterThanEquals:
+      return AssignmentOperator.GreaterThanGreaterThanAssign;
+    case TokenKind.GreaterThanGreaterThanGreaterThanEquals:
+      return AssignmentOperator.GreaterThanGreaterThanGreaterThanAssign;
+    case TokenKind.AmpersandEquals:
+      return AssignmentOperator.AmpersandAssign;
+    case TokenKind.BarEquals:
+      return AssignmentOperator.BarAssign;
+    case TokenKind.CaretEquals:
+      return AssignmentOperator.CaretAssign;
+    case TokenKind.AmpersandAmpersandEquals:
+      return AssignmentOperator.AmpersandAmpersandAssign;
+    case TokenKind.BarBarEquals:
+      return AssignmentOperator.BarBarAssign;
+    case TokenKind.QuestionQuestionEquals:
+      return AssignmentOperator.QuestionQuestionAssign;
+    default:
+      return undefined;
+  }
+}
+
+export function binaryOperator(kind: TokenKind): BinaryOperator | undefined {
+  switch (kind) {
+    case TokenKind.Plus:
+      return BinaryOperator.Add;
+    case TokenKind.Minus:
+      return BinaryOperator.Subtract;
+    case TokenKind.Asterisk:
+      return BinaryOperator.Multiply;
+    case TokenKind.Slash:
+      return BinaryOperator.Divide;
+    case TokenKind.Percent:
+      return BinaryOperator.Remainder;
+    case TokenKind.AsteriskAsterisk:
+      return BinaryOperator.Exponent;
+    case TokenKind.LessThan:
+      return BinaryOperator.LessThan;
+    case TokenKind.LessThanEquals:
+      return BinaryOperator.LessThanEquals;
+    case TokenKind.GreaterThan:
+      return BinaryOperator.GreaterThan;
+    case TokenKind.GreaterThanEquals:
+      return BinaryOperator.GreaterThanEquals;
+    case TokenKind.EqualsEquals:
+      return BinaryOperator.EqualsEquals;
+    case TokenKind.ExclamationEquals:
+      return BinaryOperator.ExclamationEquals;
+    case TokenKind.EqualsEqualsEquals:
+      return BinaryOperator.EqualsEqualsEquals;
+    case TokenKind.ExclamationEqualsEquals:
+      return BinaryOperator.ExclamationEqualsEquals;
+    case TokenKind.AmpersandAmpersand:
+      return BinaryOperator.AmpersandAmpersand;
+    case TokenKind.BarBar:
+      return BinaryOperator.BarBar;
+    case TokenKind.QuestionQuestion:
+      return BinaryOperator.QuestionQuestion;
+    case TokenKind.Ampersand:
+      return BinaryOperator.Ampersand;
+    case TokenKind.Bar:
+      return BinaryOperator.Bar;
+    case TokenKind.Caret:
+      return BinaryOperator.Caret;
+    case TokenKind.LessThanLessThan:
+      return BinaryOperator.LessThanLessThan;
+    case TokenKind.GreaterThanGreaterThan:
+      return BinaryOperator.GreaterThanGreaterThan;
+    case TokenKind.GreaterThanGreaterThanGreaterThan:
+      return BinaryOperator.GreaterThanGreaterThanGreaterThan;
+    case TokenKind.InKeyword:
+      return BinaryOperator.In;
+    case TokenKind.InstanceOfKeyword:
+      return BinaryOperator.InstanceOf;
+    default:
+      return undefined;
+  }
+}
+
+export function binaryPrecedence(op: BinaryOperator): number {
+  switch (op) {
+    case BinaryOperator.QuestionQuestion:
+      return 1;
+    case BinaryOperator.BarBar:
+      return 2;
+    case BinaryOperator.AmpersandAmpersand:
+      return 3;
+    case BinaryOperator.Bar:
+      return 4;
+    case BinaryOperator.Caret:
+      return 5;
+    case BinaryOperator.Ampersand:
+      return 6;
+    case BinaryOperator.EqualsEquals:
+    case BinaryOperator.ExclamationEquals:
+    case BinaryOperator.EqualsEqualsEquals:
+    case BinaryOperator.ExclamationEqualsEquals:
+      return 7;
+    case BinaryOperator.LessThan:
+    case BinaryOperator.LessThanEquals:
+    case BinaryOperator.GreaterThan:
+    case BinaryOperator.GreaterThanEquals:
+    case BinaryOperator.In:
+    case BinaryOperator.InstanceOf:
+      return 8;
+    case BinaryOperator.LessThanLessThan:
+    case BinaryOperator.GreaterThanGreaterThan:
+    case BinaryOperator.GreaterThanGreaterThanGreaterThan:
+      return 9;
+    case BinaryOperator.Add:
+    case BinaryOperator.Subtract:
+      return 10;
+    case BinaryOperator.Multiply:
+    case BinaryOperator.Divide:
+    case BinaryOperator.Remainder:
+      return 11;
+    case BinaryOperator.Exponent:
+      return 12;
+    default:
+      return -1;
+  }
+}
+
+export function prefixUnaryOperator(kind: TokenKind): PrefixUnaryOperator | undefined {
+  switch (kind) {
+    case TokenKind.Plus:
+      return PrefixUnaryOperator.Plus;
+    case TokenKind.Minus:
+      return PrefixUnaryOperator.Minus;
+    case TokenKind.Tilde:
+      return PrefixUnaryOperator.Tilde;
+    case TokenKind.Exclamation:
+      return PrefixUnaryOperator.Exclamation;
+    case TokenKind.TypeOfKeyword:
+      return PrefixUnaryOperator.TypeOf;
+    case TokenKind.VoidKeyword:
+      return PrefixUnaryOperator.Void;
+    case TokenKind.DeleteKeyword:
+      return PrefixUnaryOperator.Delete;
+    case TokenKind.PlusPlus:
+      return PrefixUnaryOperator.PlusPlus;
+    case TokenKind.MinusMinus:
+      return PrefixUnaryOperator.MinusMinus;
+    case TokenKind.AwaitKeyword:
+      return PrefixUnaryOperator.Await;
+    default:
+      return undefined;
+  }
+}