xbintsc 0.1.3 → 0.1.8

package/src/ast/expressions.ts

@@ -0,0 +1,275 @@
+/**
+ * Expression nodes of the xbintsc AST, plus the literal and identifier nodes
+ * they are built from.
+ */
+
+import type { Token } from "../lexer/token.js";
+import { NodeFlags, SyntaxKind } from "./kinds.js";
+import {
+  AssignmentOperator,
+  BinaryOperator,
+  PostfixUnaryOperator,
+  PrefixUnaryOperator,
+} from "./operators.js";
+import type { Expression, Node, TypeNode } from "./common.js";
+import type { Block } from "./statements.js";
+import type { ClassElement, HeritageClause, Parameter, TypeParameterDeclaration } from "./declarations.js";
+
+// ---------------------------------------------------------------------------
+// Identifiers and literals
+// ---------------------------------------------------------------------------
+
+export interface Identifier extends Node {
+  readonly kind: SyntaxKind.Identifier;
+  readonly text: string;
+  /** True when the identifier was written with a `#` prefix. */
+  readonly escaped?: boolean;
+}
+
+export interface PrivateIdentifier extends Node {
+  readonly kind: SyntaxKind.PrivateIdentifier;
+  readonly text: string;
+}
+
+export interface NumericLiteral extends Node {
+  readonly kind: SyntaxKind.NumericLiteral;
+  readonly text: string;
+  readonly value: number;
+}
+
+export interface BigIntLiteral extends Node {
+  readonly kind: SyntaxKind.BigIntLiteral;
+  readonly text: string;
+  readonly value: bigint;
+}
+
+export interface StringLiteral extends Node {
+  readonly kind: SyntaxKind.StringLiteral;
+  readonly text: string;
+  readonly value: string;
+  /** Raw source text, including quotes. */
+  readonly raw: string;
+}
+
+export interface NoSubstitutionTemplateLiteral extends Node {
+  readonly kind: SyntaxKind.NoSubstitutionTemplateLiteral;
+  readonly text: string;
+  readonly value: string;
+}
+
+export interface TemplateLiteral extends Node {
+  readonly kind: SyntaxKind.TemplateLiteral;
+  readonly head: string;
+  readonly spans: TemplateSpan[];
+}
+
+export interface TemplateSpan extends Node {
+  readonly kind: SyntaxKind.TemplateSpan;
+  readonly expression: Expression;
+  readonly literal: string;
+  /** True when this span terminates the template (tail) rather than continues it. */
+  readonly isTail: boolean;
+}
+
+export interface RegularExpressionLiteral extends Node {
+  readonly kind: SyntaxKind.RegularExpressionLiteral;
+  readonly text: string;
+  readonly pattern: string;
+  readonly flags: string;
+}
+
+export interface BooleanLiteral extends Node {
+  readonly kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword;
+  readonly value: boolean;
+}
+
+export interface NullLiteral extends Node {
+  readonly kind: SyntaxKind.NullKeyword;
+}
+
+export interface UndefinedLiteral extends Node {
+  readonly kind: SyntaxKind.UndefinedKeyword;
+}
+
+export interface ThisExpression extends Node {
+  readonly kind: SyntaxKind.ThisKeyword;
+}
+
+// ---------------------------------------------------------------------------
+// Expressions
+// ---------------------------------------------------------------------------
+
+export interface ArrayLiteralExpression extends Node {
+  readonly kind: SyntaxKind.ArrayLiteralExpression;
+  readonly elements: Expression[];
+}
+
+export interface PropertyAssignment extends Node {
+  readonly kind: SyntaxKind.PropertyAssignment;
+  readonly name: PropertyName;
+  readonly initializer: Expression;
+}
+
+export interface ShorthandPropertyAssignment extends Node {
+  readonly kind: SyntaxKind.ShorthandPropertyAssignment;
+  readonly name: Identifier;
+}
+
+export interface SpreadElement extends Node {
+  readonly kind: SyntaxKind.SpreadElement;
+  readonly expression: Expression;
+}
+
+export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadElement;
+
+export interface ObjectLiteralExpression extends Node {
+  readonly kind: SyntaxKind.ObjectLiteralExpression;
+  readonly properties: ObjectLiteralElementLike[];
+}
+
+export type PropertyName = Identifier | StringLiteral | NumericLiteral | PrivateIdentifier;
+
+export interface FunctionExpression extends Node {
+  readonly kind: SyntaxKind.FunctionExpression;
+  readonly name?: Identifier;
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly parameters: Parameter[];
+  readonly returnType?: TypeNode;
+  readonly body: Block;
+  readonly flags: NodeFlags;
+}
+
+export interface ArrowFunction extends Node {
+  readonly kind: SyntaxKind.ArrowFunction;
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly parameters: Parameter[];
+  readonly returnType?: TypeNode;
+  readonly body: Block | Expression;
+  readonly flags: NodeFlags;
+}
+
+export interface ClassExpression extends Node {
+  readonly kind: SyntaxKind.ClassExpression;
+  readonly name?: Identifier;
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly heritage: HeritageClause[];
+  readonly members: ClassElement[];
+}
+
+export interface CallExpression extends Node {
+  readonly kind: SyntaxKind.CallExpression;
+  readonly expression: Expression;
+  readonly typeArguments: TypeNode[];
+  readonly arguments: Expression[];
+  readonly optional: boolean;
+}
+
+export interface NewExpression extends Node {
+  readonly kind: SyntaxKind.NewExpression;
+  readonly expression: Expression;
+  readonly typeArguments: TypeNode[];
+  readonly arguments: Expression[];
+}
+
+export interface PropertyAccessExpression extends Node {
+  readonly kind: SyntaxKind.PropertyAccessExpression;
+  readonly expression: Expression;
+  readonly name: Identifier;
+  readonly optional: boolean;
+}
+
+export interface ElementAccessExpression extends Node {
+  readonly kind: SyntaxKind.ElementAccessExpression;
+  readonly expression: Expression;
+  readonly argumentExpression: Expression;
+  readonly optional: boolean;
+}
+
+export interface ParenthesizedExpression extends Node {
+  readonly kind: SyntaxKind.ParenthesizedExpression;
+  readonly expression: Expression;
+}
+
+export interface PrefixUnaryExpression extends Node {
+  readonly kind: SyntaxKind.PrefixUnaryExpression;
+  readonly operator: PrefixUnaryOperator;
+  readonly operand: Expression;
+}
+
+export interface PostfixUnaryExpression extends Node {
+  readonly kind: SyntaxKind.PostfixUnaryExpression;
+  readonly operator: PostfixUnaryOperator;
+  readonly operand: Expression;
+}
+
+export interface BinaryExpression extends Node {
+  readonly kind: SyntaxKind.BinaryExpression;
+  readonly left: Expression;
+  readonly operator: BinaryOperator;
+  readonly right: Expression;
+  readonly operatorToken: Token;
+}
+
+export interface AssignmentExpression extends Node {
+  readonly kind: SyntaxKind.BinaryExpression;
+  readonly left: Expression;
+  readonly operator: AssignmentOperator;
+  readonly right: Expression;
+  readonly operatorToken: Token;
+}
+
+export interface ConditionalExpression extends Node {
+  readonly kind: SyntaxKind.ConditionalExpression;
+  readonly condition: Expression;
+  readonly whenTrue: Expression;
+  readonly whenFalse: Expression;
+}
+
+export interface AsExpression extends Node {
+  readonly kind: SyntaxKind.AsExpression;
+  readonly expression: Expression;
+  readonly type: TypeNode;
+}
+
+export interface SatisfiesExpression extends Node {
+  readonly kind: SyntaxKind.SatisfiesExpression;
+  readonly expression: Expression;
+  readonly type: TypeNode;
+}
+
+export interface NonNullExpression extends Node {
+  readonly kind: SyntaxKind.NonNullExpression;
+  readonly expression: Expression;
+}
+
+export interface TypeOfExpression extends Node {
+  readonly kind: SyntaxKind.TypeOfExpression;
+  readonly expression: Expression;
+}
+
+export interface VoidExpression extends Node {
+  readonly kind: SyntaxKind.VoidExpression;
+  readonly expression?: Expression;
+}
+
+export interface DeleteExpression extends Node {
+  readonly kind: SyntaxKind.DeleteExpression;
+  readonly expression: Expression;
+}
+
+export interface AwaitExpression extends Node {
+  readonly kind: SyntaxKind.AwaitExpression;
+  readonly expression: Expression;
+}
+
+export interface YieldExpression extends Node {
+  readonly kind: SyntaxKind.YieldExpression;
+  readonly expression?: Expression;
+  readonly delegate: boolean;
+}
+
+export interface TaggedTemplateExpression extends Node {
+  readonly kind: SyntaxKind.TaggedTemplateExpression;
+  readonly tag: Expression;
+  readonly template: TemplateLiteral | NoSubstitutionTemplateLiteral;
+}

package/src/ast/kinds.ts

@@ -0,0 +1,176 @@
+/**
+ * Syntax kinds and node flags for the xbintsc AST.
+ *
+ * These numeric/string tags are the discriminants used throughout the binder,
+ * checker and code generator to switch exhaustively over nodes.
+ */
+
+export const enum SyntaxKind {
+  // Markers
+  Unknown = 0,
+  EndOfFileToken = 1,
+  SourceFile = 300,
+  QualifiedName = 301,
+  ExpressionWithTypeArguments = 302,
+  ImportType = 303,
+
+  // Trivia-ish
+  Identifier = 2,
+  PrivateIdentifier = 3,
+
+  // Literals
+  NumericLiteral = 4,
+  BigIntLiteral = 5,
+  StringLiteral = 6,
+  NoSubstitutionTemplateLiteral = 7,
+  TemplateLiteral = 8,
+  TemplateSpan = 9,
+  RegularExpressionLiteral = 10,
+  TrueKeyword = 11,
+  FalseKeyword = 12,
+  NullKeyword = 13,
+  UndefinedKeyword = 14,
+  ThisKeyword = 15,
+
+  // Expressions
+  ArrayLiteralExpression = 20,
+  ObjectLiteralExpression = 21,
+  PropertyAssignment = 22,
+  ShorthandPropertyAssignment = 23,
+  SpreadElement = 24,
+  FunctionExpression = 25,
+  ArrowFunction = 26,
+  ClassExpression = 27,
+  CallExpression = 28,
+  NewExpression = 29,
+  PropertyAccessExpression = 30,
+  ElementAccessExpression = 31,
+  ParenthesizedExpression = 32,
+  PrefixUnaryExpression = 33,
+  PostfixUnaryExpression = 34,
+  BinaryExpression = 35,
+  ConditionalExpression = 36,
+  AsExpression = 37,
+  SatisfiesExpression = 38,
+  NonNullExpression = 39,
+  TypeOfExpression = 40,
+  VoidExpression = 41,
+  DeleteExpression = 42,
+  AwaitExpression = 43,
+  YieldExpression = 44,
+  TaggedTemplateExpression = 45,
+
+  // Statements
+  ExpressionStatement = 60,
+  Block = 61,
+  EmptyStatement = 62,
+  DebuggerStatement = 63,
+  VariableStatement = 64,
+  VariableDeclarationList = 65,
+  VariableDeclaration = 66,
+  IfStatement = 67,
+  WhileStatement = 68,
+  DoStatement = 69,
+  ForStatement = 70,
+  ForOfStatement = 71,
+  ForInStatement = 72,
+  ReturnStatement = 73,
+  BreakStatement = 74,
+  ContinueStatement = 75,
+  ThrowStatement = 76,
+  TryStatement = 77,
+  CatchClause = 78,
+  SwitchStatement = 79,
+  CaseClause = 80,
+  DefaultClause = 81,
+  LabeledStatement = 82,
+
+  // Declarations
+  FunctionDeclaration = 100,
+  ClassDeclaration = 101,
+  InterfaceDeclaration = 102,
+  TypeAliasDeclaration = 103,
+  EnumDeclaration = 104,
+  EnumMember = 105,
+  ModuleDeclaration = 106,
+  Parameter = 107,
+  TypeParameterDeclaration = 108,
+  PropertyDeclaration = 109,
+  MethodDeclaration = 110,
+  ConstructorDeclaration = 111,
+  HeritageClause = 112,
+  ImportDeclaration = 113,
+  ImportClause = 114,
+  NamedImports = 115,
+  ImportSpecifier = 116,
+  NamespaceImport = 117,
+  ExportDeclaration = 118,
+  ExportAssignment = 119,
+  NamedExports = 120,
+  ExportSpecifier = 121,
+
+  // Types
+  TypeReference = 200,
+  TypePredicate = 201,
+  AnyKeywordType = 202,
+  UnknownKeywordType = 203,
+  NumberKeywordType = 204,
+  BigIntKeywordType = 205,
+  StringKeywordType = 206,
+  BooleanKeywordType = 207,
+  SymbolKeywordType = 208,
+  VoidKeywordType = 209,
+  UndefinedKeywordType = 210,
+  NullKeywordType = 211,
+  NeverKeywordType = 212,
+  ObjectKeywordType = 213,
+  ThisKeywordType = 214,
+  LiteralType = 215,
+  ArrayType = 216,
+  TupleType = 217,
+  UnionType = 218,
+  IntersectionType = 219,
+  FunctionType = 220,
+  TypeLiteral = 221,
+  PropertySignature = 222,
+  MethodSignature = 223,
+  IndexSignature = 224,
+  ParenthesizedType = 225,
+  TypeQuery = 226,
+  IndexedAccessType = 227,
+  TypeOperator = 228,
+  MappedType = 229,
+  ConditionalType = 230,
+  InferType = 231,
+  OptionalType = 232,
+  RestType = 233,
+}
+
+export const enum NodeFlags {
+  None = 0,
+  Let = 1 << 0,
+  Const = 1 << 1,
+  Var = 1 << 2,
+  Exported = 1 << 3,
+  Default = 1 << 4,
+  Declare = 1 << 5,
+  Async = 1 << 6,
+  Generator = 1 << 7,
+  Ambient = 1 << 8,
+  Readonly = 1 << 9,
+  Abstract = 1 << 10,
+  Optional = 1 << 11,
+}
+
+export const enum ModifierKind {
+  Export = "export",
+  Default = "default",
+  Declare = "declare",
+  Abstract = "abstract",
+  Public = "public",
+  Private = "private",
+  Protected = "protected",
+  Static = "static",
+  Readonly = "readonly",
+  Async = "async",
+}

package/src/ast/modules.ts

@@ -0,0 +1,73 @@
+/**
+ * Import and export declaration nodes of the xbintsc AST.
+ */
+
+import { SyntaxKind } from "./kinds.js";
+import type { Expression, Modifier, Node } from "./common.js";
+import type { Identifier, StringLiteral } from "./expressions.js";
+
+// ---------------------------------------------------------------------------
+// Modules
+// ---------------------------------------------------------------------------
+
+export interface ImportSpecifier extends Node {
+  readonly kind: SyntaxKind.ImportSpecifier;
+  readonly propertyName?: Identifier;
+  readonly name: Identifier;
+  readonly isTypeOnly: boolean;
+}
+
+export interface NamedImports extends Node {
+  readonly kind: SyntaxKind.NamedImports;
+  readonly elements: ImportSpecifier[];
+}
+
+export interface NamespaceImport extends Node {
+  readonly kind: SyntaxKind.NamespaceImport;
+  readonly name: Identifier;
+}
+
+export interface ImportClause extends Node {
+  readonly kind: SyntaxKind.ImportClause;
+  readonly name?: Identifier;
+  readonly namedBindings?: NamedImports | NamespaceImport;
+  readonly isTypeOnly: boolean;
+}
+
+export interface ImportDeclaration extends Node {
+  readonly kind: SyntaxKind.ImportDeclaration;
+  readonly importClause?: ImportClause;
+  readonly moduleSpecifier: StringLiteral;
+  readonly attributes: { name: string; value: string }[];
+}
+
+export interface ExportSpecifier extends Node {
+  readonly kind: SyntaxKind.ExportSpecifier;
+  readonly propertyName?: Identifier;
+  readonly name: Identifier;
+  readonly isTypeOnly: boolean;
+}
+
+export interface NamedExports extends Node {
+  readonly kind: SyntaxKind.NamedExports;
+  readonly elements: ExportSpecifier[];
+}
+
+export interface ExportDeclaration extends Node {
+  readonly kind: SyntaxKind.ExportDeclaration;
+  readonly modifiers: Modifier[];
+  readonly exportClause?: NamedExports | NamespaceExport;
+  readonly moduleSpecifier?: StringLiteral;
+  readonly isTypeOnly: boolean;
+}
+
+export interface NamespaceExport extends Node {
+  readonly kind: SyntaxKind.NamespaceImport;
+  readonly name: Identifier;
+}
+
+export interface ExportAssignment extends Node {
+  readonly kind: SyntaxKind.ExportAssignment;
+  readonly isExportEquals: boolean;
+  readonly expression: Expression;
+}