xbintsc 0.1.3 → 0.1.8

package/src/ast/operators.ts

@@ -0,0 +1,76 @@
+/**
+ * Operator taxonomies shared by the parser and code generator.
+ */
+
+export const enum PrefixUnaryOperator {
+  Plus = "+",
+  Minus = "-",
+  Tilde = "~",
+  Exclamation = "!",
+  TypeOf = "typeof",
+  Void = "void",
+  Delete = "delete",
+  PlusPlus = "++",
+  MinusMinus = "--",
+  Await = "await",
+}
+
+export const enum PostfixUnaryOperator {
+  PlusPlus = "++",
+  MinusMinus = "--",
+}
+
+export const enum BinaryOperator {
+  Add = "+",
+  Subtract = "-",
+  Multiply = "*",
+  Divide = "/",
+  Remainder = "%",
+  Exponent = "**",
+  LessThan = "<",
+  LessThanEquals = "<=",
+  GreaterThan = ">",
+  GreaterThanEquals = ">=",
+  EqualsEquals = "==",
+  ExclamationEquals = "!=",
+  EqualsEqualsEquals = "===",
+  ExclamationEqualsEquals = "!==",
+  AmpersandAmpersand = "&&",
+  BarBar = "||",
+  QuestionQuestion = "??",
+  Ampersand = "&",
+  Bar = "|",
+  Caret = "^",
+  LessThanLessThan = "<<",
+  GreaterThanGreaterThan = ">>",
+  GreaterThanGreaterThanGreaterThan = ">>>",
+  Comma = ",",
+  In = "in",
+  InstanceOf = "instanceof",
+}
+
+/** Assignment operators, including the compound forms. */
+export const enum AssignmentOperator {
+  Assign = "=",
+  AddAssign = "+=",
+  SubtractAssign = "-=",
+  MultiplyAssign = "*=",
+  DivideAssign = "/=",
+  RemainderAssign = "%=",
+  ExponentAssign = "**=",
+  LessThanLessThanAssign = "<<=",
+  GreaterThanGreaterThanAssign = ">>=",
+  GreaterThanGreaterThanGreaterThanAssign = ">>>=",
+  AmpersandAssign = "&=",
+  BarAssign = "|=",
+  CaretAssign = "^=",
+  AmpersandAmpersandAssign = "&&=",
+  BarBarAssign = "||=",
+  QuestionQuestionAssign = "??=",
+}
+
+export const enum TypeOperator {
+  KeyOf = "keyof",
+  Unique = "unique",
+  Readonly = "readonly",
+}

package/src/ast/statements.ts

@@ -0,0 +1,148 @@
+/**
+ * Statement nodes of the xbintsc AST.
+ */
+
+import { SyntaxKind } from "./kinds.js";
+import type { Expression, Modifier, Node, Statement, TypeNode } from "./common.js";
+import type { Identifier } from "./expressions.js";
+
+// ---------------------------------------------------------------------------
+// Statements
+// ---------------------------------------------------------------------------
+
+export interface ExpressionStatement extends Node {
+  readonly kind: SyntaxKind.ExpressionStatement;
+  readonly expression: Expression;
+}
+
+export interface Block extends Node {
+  readonly kind: SyntaxKind.Block;
+  readonly statements: Statement[];
+}
+
+export interface EmptyStatement extends Node {
+  readonly kind: SyntaxKind.EmptyStatement;
+}
+
+export interface DebuggerStatement extends Node {
+  readonly kind: SyntaxKind.DebuggerStatement;
+}
+
+export interface VariableDeclaration extends Node {
+  readonly kind: SyntaxKind.VariableDeclaration;
+  readonly name: Identifier;
+  readonly exclamation: boolean;
+  readonly type?: TypeNode;
+  readonly initializer?: Expression;
+}
+
+export interface VariableDeclarationList extends Node {
+  readonly kind: SyntaxKind.VariableDeclarationList;
+  readonly declarations: VariableDeclaration[];
+  readonly declarationKind: "var" | "let" | "const" | "using";
+}
+
+export interface VariableStatement extends Node {
+  readonly kind: SyntaxKind.VariableStatement;
+  readonly declarationList: VariableDeclarationList;
+  readonly modifiers: Modifier[];
+}
+
+export interface IfStatement extends Node {
+  readonly kind: SyntaxKind.IfStatement;
+  readonly condition: Expression;
+  readonly thenStatement: Statement;
+  readonly elseStatement?: Statement;
+}
+
+export interface WhileStatement extends Node {
+  readonly kind: SyntaxKind.WhileStatement;
+  readonly condition: Expression;
+  readonly statement: Statement;
+}
+
+export interface DoStatement extends Node {
+  readonly kind: SyntaxKind.DoStatement;
+  readonly condition: Expression;
+  readonly statement: Statement;
+}
+
+export interface ForStatement extends Node {
+  readonly kind: SyntaxKind.ForStatement;
+  readonly initializer?: VariableDeclarationList | Expression;
+  readonly condition?: Expression;
+  readonly incrementor?: Expression;
+  readonly statement: Statement;
+}
+
+export interface ForOfStatement extends Node {
+  readonly kind: SyntaxKind.ForOfStatement;
+  readonly initializer: VariableDeclarationList | Expression;
+  readonly expression: Expression;
+  readonly statement: Statement;
+  readonly awaitModifier: boolean;
+}
+
+export interface ForInStatement extends Node {
+  readonly kind: SyntaxKind.ForInStatement;
+  readonly initializer: VariableDeclarationList | Expression;
+  readonly expression: Expression;
+  readonly statement: Statement;
+}
+
+export interface ReturnStatement extends Node {
+  readonly kind: SyntaxKind.ReturnStatement;
+  readonly expression?: Expression;
+}
+
+export interface BreakStatement extends Node {
+  readonly kind: SyntaxKind.BreakStatement;
+  readonly label?: Identifier;
+}
+
+export interface ContinueStatement extends Node {
+  readonly kind: SyntaxKind.ContinueStatement;
+  readonly label?: Identifier;
+}
+
+export interface ThrowStatement extends Node {
+  readonly kind: SyntaxKind.ThrowStatement;
+  readonly expression: Expression;
+}
+
+export interface CatchClause extends Node {
+  readonly kind: SyntaxKind.CatchClause;
+  readonly variable?: Identifier;
+  readonly type?: TypeNode;
+  readonly block: Block;
+}
+
+export interface TryStatement extends Node {
+  readonly kind: SyntaxKind.TryStatement;
+  readonly tryBlock: Block;
+  readonly catchClause?: CatchClause;
+  readonly finallyBlock?: Block;
+}
+
+export interface CaseClause extends Node {
+  readonly kind: SyntaxKind.CaseClause;
+  readonly expression: Expression;
+  readonly statements: Statement[];
+}
+
+export interface DefaultClause extends Node {
+  readonly kind: SyntaxKind.DefaultClause;
+  readonly statements: Statement[];
+}
+
+export interface SwitchStatement extends Node {
+  readonly kind: SyntaxKind.SwitchStatement;
+  readonly expression: Expression;
+  readonly clauses: (CaseClause | DefaultClause)[];
+}
+
+export interface LabeledStatement extends Node {
+  readonly kind: SyntaxKind.LabeledStatement;
+  readonly label: Identifier;
+  readonly statement: Statement;
+}

package/src/ast/types.ts

@@ -0,0 +1,173 @@
+/**
+ * Type nodes of the xbintsc AST. The parser records type syntax so diagnostics
+ * and tooling can see it, but the code generator erases types before lowering.
+ */
+
+import { SyntaxKind } from "./kinds.js";
+import type { TypeOperator } from "./operators.js";
+import type { Node, TypeNode } from "./common.js";
+import type {
+  BooleanLiteral,
+  Identifier,
+  NullLiteral,
+  NumericLiteral,
+  StringLiteral,
+  ThisExpression,
+  PropertyName,
+} from "./expressions.js";
+import type { Parameter, TypeParameterDeclaration } from "./declarations.js";
+
+// ---------------------------------------------------------------------------
+// Type nodes
+// ---------------------------------------------------------------------------
+
+export interface TypeReference extends Node {
+  readonly kind: SyntaxKind.TypeReference;
+  readonly typeName: Identifier | QualifiedName;
+  readonly typeArguments: TypeNode[];
+}
+
+export interface QualifiedName extends Node {
+  readonly kind: SyntaxKind.QualifiedName;
+  readonly left: Identifier | QualifiedName;
+  readonly right: Identifier;
+}
+
+export interface TypePredicate extends Node {
+  readonly kind: SyntaxKind.TypePredicate;
+  readonly parameterName: Identifier | ThisExpression;
+  readonly type?: TypeNode;
+}
+
+export interface KeywordTypeNode extends Node {
+  readonly kind:
+    | SyntaxKind.AnyKeywordType
+    | SyntaxKind.UnknownKeywordType
+    | SyntaxKind.NumberKeywordType
+    | SyntaxKind.BigIntKeywordType
+    | SyntaxKind.StringKeywordType
+    | SyntaxKind.BooleanKeywordType
+    | SyntaxKind.SymbolKeywordType
+    | SyntaxKind.VoidKeywordType
+    | SyntaxKind.UndefinedKeywordType
+    | SyntaxKind.NullKeywordType
+    | SyntaxKind.NeverKeywordType
+    | SyntaxKind.ObjectKeywordType
+    | SyntaxKind.ThisKeywordType;
+}
+
+export interface LiteralTypeNode extends Node {
+  readonly kind: SyntaxKind.LiteralType;
+  readonly literal: StringLiteral | NumericLiteral | BooleanLiteral | NullLiteral;
+}
+
+export interface ArrayTypeNode extends Node {
+  readonly kind: SyntaxKind.ArrayType;
+  readonly elementType: TypeNode;
+}
+
+export interface TupleTypeNode extends Node {
+  readonly kind: SyntaxKind.TupleType;
+  readonly elements: TypeNode[];
+}
+
+export interface UnionTypeNode extends Node {
+  readonly kind: SyntaxKind.UnionType;
+  readonly types: TypeNode[];
+}
+
+export interface IntersectionTypeNode extends Node {
+  readonly kind: SyntaxKind.IntersectionType;
+  readonly types: TypeNode[];
+}
+
+export interface FunctionTypeNode extends Node {
+  readonly kind: SyntaxKind.FunctionType;
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly parameters: Parameter[];
+  readonly returnType: TypeNode;
+}
+
+export type TypeElement = PropertySignature | MethodSignature | IndexSignature;
+
+export interface PropertySignature extends Node {
+  readonly kind: SyntaxKind.PropertySignature;
+  readonly name: PropertyName;
+  readonly questionToken: boolean;
+  readonly readonlyToken: boolean;
+  readonly type?: TypeNode;
+}
+
+export interface MethodSignature extends Node {
+  readonly kind: SyntaxKind.MethodSignature;
+  readonly name: PropertyName;
+  readonly questionToken: boolean;
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly parameters: Parameter[];
+  readonly returnType?: TypeNode;
+}
+
+export interface IndexSignature extends Node {
+  readonly kind: SyntaxKind.IndexSignature;
+  readonly parameters: Parameter[];
+  readonly type?: TypeNode;
+}
+
+export interface TypeLiteralNode extends Node {
+  readonly kind: SyntaxKind.TypeLiteral;
+  readonly members: TypeElement[];
+}
+
+export interface ParenthesizedTypeNode extends Node {
+  readonly kind: SyntaxKind.ParenthesizedType;
+  readonly type: TypeNode;
+}
+
+export interface TypeQueryNode extends Node {
+  readonly kind: SyntaxKind.TypeQuery;
+  readonly exprName: Identifier | QualifiedName;
+  readonly typeArguments: TypeNode[];
+}
+
+export interface IndexedAccessTypeNode extends Node {
+  readonly kind: SyntaxKind.IndexedAccessType;
+  readonly objectType: TypeNode;
+  readonly indexType: TypeNode;
+}
+
+export interface TypeOperatorNode extends Node {
+  readonly kind: SyntaxKind.TypeOperator;
+  readonly operator: TypeOperator;
+  readonly type: TypeNode;
+}
+
+export interface MappedTypeNode extends Node {
+  readonly kind: SyntaxKind.MappedType;
+  readonly readonlyToken: boolean | "+" | "-";
+  readonly typeParameter: TypeParameterDeclaration;
+  readonly questionToken: boolean | "+" | "-";
+  readonly type?: TypeNode;
+}
+
+export interface ConditionalTypeNode extends Node {
+  readonly kind: SyntaxKind.ConditionalType;
+  readonly checkType: TypeNode;
+  readonly extendsType: TypeNode;
+  readonly trueType: TypeNode;
+  readonly falseType: TypeNode;
+}
+
+export interface InferTypeNode extends Node {
+  readonly kind: SyntaxKind.InferType;
+  readonly typeParameter: TypeParameterDeclaration;
+}
+
+export interface OptionalTypeNode extends Node {
+  readonly kind: SyntaxKind.OptionalType;
+  readonly type: TypeNode;
+}
+
+export interface RestTypeNode extends Node {
+  readonly kind: SyntaxKind.RestType;
+  readonly type: TypeNode;
+}