xbintsc 0.1.3 → 0.1.8

package/runtime/xt_values.c

@@ -0,0 +1,291 @@
+/*
+ * xbintsc runtime — values.
+ *
+ * Constructors, the string representation, JS conversions, arithmetic and
+ * comparison operators. All of these operate on the NaN-boxed `xt_value`.
+ */
+
+#include "rt_internal.h"
+
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+/* ------------------------------------------------------------------------- */
+/* Constructors                                                              */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_undefined(void) { return XT_UNDEFINED; }
+xt_value xt_null(void) { return XT_NULL; }
+xt_value xt_bool(int b) { return b ? XT_TRUE : XT_FALSE; }
+xt_value xt_number(double d) { return xt_from_double(d); }
+
+xt_string *xt_string_alloc(size_t length) {
+  xt_string *s = (xt_string *)xt_alloc(sizeof(xt_string), XT_OBJECT_KIND_STRING);
+  s->length = (uint32_t)length;
+  s->capacity = (uint32_t)length + 1;
+  s->data = (char *)malloc(s->capacity);
+  if (!s->data) {
+    fprintf(stderr, "xbintsc: out of memory allocating string\n");
+    abort();
+  }
+  s->data[length] = '\0';
+  return s;
+}
+
+xt_value xt_string_new(const char *data, size_t len) {
+  xt_string *s = xt_string_alloc(len);
+  if (len > 0) memcpy(s->data, data, len);
+  return XT_FROM_PTR(XT_TAG_STRING, s);
+}
+
+xt_value xt_string_from_cstr(const char *data) { return xt_string_new(data, strlen(data)); }
+
+xt_string *xt_as_string(xt_value v);
+
+const char *xt_string_data(xt_value value) {
+  xt_string *s = xt_as_string(value);
+  return s ? s->data : NULL;
+}
+
+int32_t xt_string_length_value(xt_value value) {
+  xt_string *s = xt_as_string(value);
+  return s ? (int32_t)s->length : -1;
+}
+
+/* ------------------------------------------------------------------------- */
+/* Strings                                                                   */
+/* ------------------------------------------------------------------------- */
+
+xt_string *xt_as_string(xt_value v) {
+  if (XT_IS_STRING(v)) return (xt_string *)XT_GET_PTR(v);
+  return NULL;
+}
+
+int32_t xt_string_length(xt_string *s) { return (int32_t)s->length; }
+
+static xt_value xt_string_concat(xt_string *a, xt_string *b) {
+  size_t total = (size_t)a->length + (size_t)b->length;
+  xt_string *out = xt_string_alloc(total);
+  memcpy(out->data, a->data, a->length);
+  memcpy(out->data + a->length, b->data, b->length);
+  return XT_FROM_PTR(XT_TAG_STRING, out);
+}
+
+int xt_string_equals(xt_string *a, xt_string *b) {
+  return a->length == b->length && memcmp(a->data, b->data, a->length) == 0;
+}
+
+/*
+ * Format a double the way JavaScript's ToString does for the common cases:
+ * integers print without a decimal point, everything else uses the shortest
+ * representation that round-trips.
+ */
+static void xt_format_double(double d, char *buffer, size_t size) {
+  if (isnan(d)) {
+    snprintf(buffer, size, "NaN");
+    return;
+  }
+  if (isinf(d)) {
+    snprintf(buffer, size, d < 0 ? "-Infinity" : "Infinity");
+    return;
+  }
+  if (d == 0.0) {
+    snprintf(buffer, size, "0");
+    return;
+  }
+  if (d == floor(d) && fabs(d) < 1e21) {
+    snprintf(buffer, size, "%.0f", d);
+    return;
+  }
+  for (int precision = 1; precision <= 17; precision++) {
+    snprintf(buffer, size, "%.*g", precision, d);
+    if (strtod(buffer, NULL) == d) return;
+  }
+}
+
+/* ------------------------------------------------------------------------- */
+/* Conversions                                                               */
+/* ------------------------------------------------------------------------- */
+
+int xt_truthy(xt_value v) {
+  if (XT_IS_NUMBER(v)) {
+    double d = xt_to_double(v);
+    return d != 0.0 && !isnan(d);
+  }
+  if (v == XT_UNDEFINED || v == XT_NULL) return 0;
+  if (v == XT_FALSE) return 0;
+  if (v == XT_TRUE) return 1;
+  return 1; /* objects, arrays, functions and non-empty strings are truthy */
+}
+
+double xt_to_number(xt_value v) {
+  if (XT_IS_NUMBER(v)) return xt_to_double(v);
+  if (v == XT_TRUE) return 1.0;
+  if (v == XT_FALSE) return 0.0;
+  if (v == XT_UNDEFINED) return NAN;
+  if (v == XT_NULL) return 0.0;
+  if (XT_IS_STRING(v)) {
+    xt_string *s = xt_as_string(v);
+    if (s->length == 0) return 0.0;
+    char *end = NULL;
+    double parsed = strtod(s->data, &end);
+    if (end != s->data + s->length) return NAN;
+    return parsed;
+  }
+  return NAN;
+}
+
+static xt_value xt_number_to_string_value(double d) {
+  char buffer[64];
+  xt_format_double(d, buffer, sizeof(buffer));
+  return xt_string_from_cstr(buffer);
+}
+
+xt_value xt_to_string(xt_value v) {
+  if (XT_IS_STRING(v)) return v;
+  if (XT_IS_NUMBER(v)) return xt_number_to_string_value(xt_to_double(v));
+  if (v == XT_UNDEFINED) return xt_string_from_cstr("undefined");
+  if (v == XT_NULL) return xt_string_from_cstr("null");
+  if (v == XT_TRUE) return xt_string_from_cstr("true");
+  if (v == XT_FALSE) return xt_string_from_cstr("false");
+  if (XT_IS_ARRAY(v)) {
+    xt_array *a = (xt_array *)XT_GET_PTR(v);
+    /* Join elements with commas, like Array.prototype.toString. */
+    size_t capacity = 32;
+    char *out = (char *)malloc(capacity);
+    size_t length = 0;
+    out[0] = '\0';
+    for (uint32_t i = 0; i < a->length; i++) {
+      xt_value s = xt_to_string(a->items[i]);
+      xt_string *str = xt_as_string(s);
+      if (length + str->length + 2 > capacity) {
+        capacity = (length + str->length + 2) * 2;
+        out = (char *)realloc(out, capacity);
+      }
+      if (i > 0) out[length++] = ',';
+      memcpy(out + length, str->data, str->length);
+      length += str->length;
+      out[length] = '\0';
+    }
+    xt_value result = xt_string_new(out, length);
+    free(out);
+    return result;
+  }
+  if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function () { [native code] }");
+  return xt_string_from_cstr("[object Object]");
+}
+
+xt_value xt_typeof(xt_value v) {
+  if (XT_IS_NUMBER(v)) return xt_string_from_cstr("number");
+  if (XT_IS_STRING(v)) return xt_string_from_cstr("string");
+  if (v == XT_TRUE || v == XT_FALSE) return xt_string_from_cstr("boolean");
+  if (v == XT_UNDEFINED) return xt_string_from_cstr("undefined");
+  if (XT_IS_FUNCTION(v)) return xt_string_from_cstr("function");
+  if (v == XT_NULL) return xt_string_from_cstr("object");
+  return xt_string_from_cstr("object");
+}
+
+/* ------------------------------------------------------------------------- */
+/* Arithmetic                                                                */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_add(xt_value a, xt_value b) {
+  if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) {
+    return xt_number(xt_to_double(a) + xt_to_double(b));
+  }
+  /* JavaScript's `+` concatenates when either operand is a string. */
+  if (XT_IS_STRING(a) || XT_IS_STRING(b)) {
+    xt_value sa = xt_to_string(a);
+    xt_value sb = xt_to_string(b);
+    return xt_string_concat(xt_as_string(sa), xt_as_string(sb));
+  }
+  return xt_number(xt_to_number(a) + xt_to_number(b));
+}
+
+xt_value xt_sub(xt_value a, xt_value b) { return xt_number(xt_to_number(a) - xt_to_number(b)); }
+xt_value xt_mul(xt_value a, xt_value b) { return xt_number(xt_to_number(a) * xt_to_number(b)); }
+xt_value xt_div(xt_value a, xt_value b) { return xt_number(xt_to_number(a) / xt_to_number(b)); }
+
+xt_value xt_mod(xt_value a, xt_value b) {
+  double x = xt_to_number(a);
+  double y = xt_to_number(b);
+  return xt_number(fmod(x, y));
+}
+
+xt_value xt_pow(xt_value a, xt_value b) { return xt_number(pow(xt_to_number(a), xt_to_number(b))); }
+xt_value xt_neg(xt_value a) { return xt_number(-xt_to_number(a)); }
+xt_value xt_pos(xt_value a) { return xt_number(xt_to_number(a)); }
+
+int32_t xt_to_int32(xt_value v) {
+  double d = xt_to_number(v);
+  if (isnan(d) || isinf(d)) return 0;
+  return (int32_t)(uint32_t)(int64_t)d;
+}
+
+xt_value xt_bit_and(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) & xt_to_int32(b))); }
+xt_value xt_bit_or(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) | xt_to_int32(b))); }
+xt_value xt_bit_xor(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) ^ xt_to_int32(b))); }
+xt_value xt_bit_not(xt_value a) { return xt_number((double)(~xt_to_int32(a))); }
+xt_value xt_shl(xt_value a, xt_value b) { return xt_number((double)(int32_t)((uint32_t)xt_to_int32(a) << (xt_to_int32(b) & 31))); }
+xt_value xt_shr(xt_value a, xt_value b) { return xt_number((double)(xt_to_int32(a) >> (xt_to_int32(b) & 31))); }
+xt_value xt_ushr(xt_value a, xt_value b) {
+  return xt_number((double)(uint32_t)((uint32_t)xt_to_int32(a) >> (xt_to_int32(b) & 31)));
+}
+
+/* ------------------------------------------------------------------------- */
+/* Comparison                                                                */
+/* ------------------------------------------------------------------------- */
+
+xt_value xt_lt(xt_value a, xt_value b) {
+  if (XT_IS_STRING(a) && XT_IS_STRING(b)) {
+    xt_string *x = xt_as_string(a);
+    xt_string *y = xt_as_string(b);
+    size_t n = x->length < y->length ? x->length : y->length;
+    int cmp = memcmp(x->data, y->data, n);
+    if (cmp == 0) return xt_bool(x->length < y->length);
+    return xt_bool(cmp < 0);
+  }
+  return xt_bool(xt_to_number(a) < xt_to_number(b));
+}
+
+xt_value xt_le(xt_value a, xt_value b) {
+  if (XT_IS_STRING(a) && XT_IS_STRING(b)) {
+    xt_string *x = xt_as_string(a);
+    xt_string *y = xt_as_string(b);
+    size_t n = x->length < y->length ? x->length : y->length;
+    int cmp = memcmp(x->data, y->data, n);
+    if (cmp == 0) return xt_bool(x->length <= y->length);
+    return xt_bool(cmp < 0);
+  }
+  return xt_bool(xt_to_number(a) <= xt_to_number(b));
+}
+
+xt_value xt_gt(xt_value a, xt_value b) { return xt_lt(b, a); }
+xt_value xt_ge(xt_value a, xt_value b) { return xt_le(b, a); }
+
+static int xt_loose_equals(xt_value a, xt_value b) {
+  if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) return xt_to_double(a) == xt_to_double(b);
+  if (XT_IS_STRING(a) && XT_IS_STRING(b)) return xt_string_equals(xt_as_string(a), xt_as_string(b));
+  if (a == b) return 1;
+  if ((a == XT_NULL && b == XT_UNDEFINED) || (a == XT_UNDEFINED && b == XT_NULL)) return 1;
+  if (XT_IS_BOOL(a)) return xt_loose_equals(xt_number(xt_to_number(a)), b);
+  if (XT_IS_BOOL(b)) return xt_loose_equals(a, xt_number(xt_to_number(b)));
+  if (XT_IS_STRING(a) && XT_IS_NUMBER(b)) return xt_to_number(a) == xt_to_double(b);
+  if (XT_IS_NUMBER(a) && XT_IS_STRING(b)) return xt_to_double(a) == xt_to_number(b);
+  return 0;
+}
+
+xt_value xt_eq(xt_value a, xt_value b) { return xt_bool(xt_loose_equals(a, b)); }
+xt_value xt_ne(xt_value a, xt_value b) { return xt_bool(!xt_loose_equals(a, b)); }
+
+xt_value xt_seq(xt_value a, xt_value b) {
+  if (XT_IS_NUMBER(a) && XT_IS_NUMBER(b)) return xt_bool(xt_to_double(a) == xt_to_double(b));
+  if (XT_IS_STRING(a) && XT_IS_STRING(b)) return xt_bool(xt_string_equals(xt_as_string(a), xt_as_string(b)));
+  return xt_bool(a == b);
+}
+
+xt_value xt_sne(xt_value a, xt_value b) { return xt_bool(!xt_truthy(xt_seq(a, b))); }
+xt_value xt_not(xt_value a) { return xt_bool(!xt_truthy(a)); }
+

package/scripts/build-runtime.mjs

@@ -18,7 +18,14 @@ mkdirSync(outDir, { recursive: true });
 const clang = process.env.xbintsc_CLANG ?? "clang";
 
 const sources = [
-  ["xt_runtime.c", "xt_runtime.o"],
+  // Core runtime, split into translation units (see runtime/rt_internal.h).
+  ["xt_alloc.c", "xt_alloc.o"],
+  ["xt_values.c", "xt_values.o"],
+  ["xt_containers.c", "xt_containers.o"],
+  ["xt_stdlib.c", "xt_stdlib.o"],
+  ["xt_builtins.c", "xt_builtins.o"],
+  ["xt_io.c", "xt_io.o"],
+  // Node extension sources.
   ["ext_node/fs/read_file.c", "ext_node_fs_read_file.o"],
 ];
 

package/src/ast/common.ts

@@ -0,0 +1,210 @@
+/**
+ * Core AST shapes shared by every node category: source ranges, the base
+ * `Node` interface, the `Modifier` node and the `Expression`/`Statement`/
+ * `TypeNode` discriminated unions.
+ */
+
+import { SyntaxKind, type ModifierKind } from "./kinds.js";
+import type {
+  ArrayLiteralExpression,
+  ArrowFunction,
+  AsExpression,
+  AwaitExpression,
+  BigIntLiteral,
+  BinaryExpression,
+  BooleanLiteral,
+  CallExpression,
+  ClassExpression,
+  ConditionalExpression,
+  DeleteExpression,
+  ElementAccessExpression,
+  FunctionExpression,
+  Identifier,
+  NewExpression,
+  NoSubstitutionTemplateLiteral,
+  NonNullExpression,
+  NullLiteral,
+  NumericLiteral,
+  ObjectLiteralExpression,
+  ParenthesizedExpression,
+  PostfixUnaryExpression,
+  PrefixUnaryExpression,
+  PrivateIdentifier,
+  PropertyAccessExpression,
+  RegularExpressionLiteral,
+  SatisfiesExpression,
+  SpreadElement,
+  StringLiteral,
+  TaggedTemplateExpression,
+  TemplateLiteral,
+  ThisExpression,
+  TypeOfExpression,
+  UndefinedLiteral,
+  VoidExpression,
+  YieldExpression,
+} from "./expressions.js";
+import type {
+  Block,
+  BreakStatement,
+  ContinueStatement,
+  DebuggerStatement,
+  DoStatement,
+  EmptyStatement,
+  ExpressionStatement,
+  ForInStatement,
+  ForOfStatement,
+  ForStatement,
+  IfStatement,
+  LabeledStatement,
+  ReturnStatement,
+  SwitchStatement,
+  ThrowStatement,
+  TryStatement,
+  VariableStatement,
+  WhileStatement,
+} from "./statements.js";
+import type {
+  ClassDeclaration,
+  EnumDeclaration,
+  FunctionDeclaration,
+  InterfaceDeclaration,
+  ModuleDeclaration,
+  TypeAliasDeclaration,
+} from "./declarations.js";
+import type {
+  ExportAssignment,
+  ExportDeclaration,
+  ImportDeclaration,
+} from "./modules.js";
+import type {
+  ArrayTypeNode,
+  ConditionalTypeNode,
+  FunctionTypeNode,
+  IndexedAccessTypeNode,
+  InferTypeNode,
+  IntersectionTypeNode,
+  KeywordTypeNode,
+  LiteralTypeNode,
+  MappedTypeNode,
+  OptionalTypeNode,
+  ParenthesizedTypeNode,
+  RestTypeNode,
+  TupleTypeNode,
+  TypeLiteralNode,
+  TypeOperatorNode,
+  TypePredicate,
+  TypeQueryNode,
+  TypeReference,
+  UnionTypeNode,
+} from "./types.js";
+
+export interface Range {
+  /** Inclusive start offset (UTF-16 code units). */
+  readonly start: number;
+  /** Exclusive end offset. */
+  readonly end: number;
+}
+
+export interface Node extends Range {
+  readonly kind: SyntaxKind;
+}
+
+export interface Modifier extends Node {
+  readonly kind: SyntaxKind.Unknown;
+  readonly modifierKind: ModifierKind;
+}
+
+export type Expression =
+  | Identifier
+  | PrivateIdentifier
+  | NumericLiteral
+  | BigIntLiteral
+  | StringLiteral
+  | NoSubstitutionTemplateLiteral
+  | TemplateLiteral
+  | RegularExpressionLiteral
+  | BooleanLiteral
+  | NullLiteral
+  | UndefinedLiteral
+  | ThisExpression
+  | ArrayLiteralExpression
+  | ObjectLiteralExpression
+  | FunctionExpression
+  | ArrowFunction
+  | ClassExpression
+  | CallExpression
+  | NewExpression
+  | PropertyAccessExpression
+  | ElementAccessExpression
+  | ParenthesizedExpression
+  | PrefixUnaryExpression
+  | PostfixUnaryExpression
+  | BinaryExpression
+  | ConditionalExpression
+  | AsExpression
+  | SatisfiesExpression
+  | NonNullExpression
+  | TypeOfExpression
+  | VoidExpression
+  | DeleteExpression
+  | AwaitExpression
+  | YieldExpression
+  | TaggedTemplateExpression
+  | SpreadElement;
+
+export type Statement =
+  | ExpressionStatement
+  | Block
+  | EmptyStatement
+  | DebuggerStatement
+  | VariableStatement
+  | IfStatement
+  | WhileStatement
+  | DoStatement
+  | ForStatement
+  | ForOfStatement
+  | ForInStatement
+  | ReturnStatement
+  | BreakStatement
+  | ContinueStatement
+  | ThrowStatement
+  | TryStatement
+  | SwitchStatement
+  | LabeledStatement
+  | FunctionDeclaration
+  | ClassDeclaration
+  | InterfaceDeclaration
+  | TypeAliasDeclaration
+  | EnumDeclaration
+  | ModuleDeclaration
+  | ImportDeclaration
+  | ExportDeclaration
+  | ExportAssignment;
+
+export type TypeNode =
+  | TypeReference
+  | TypePredicate
+  | KeywordTypeNode
+  | LiteralTypeNode
+  | ArrayTypeNode
+  | TupleTypeNode
+  | UnionTypeNode
+  | IntersectionTypeNode
+  | FunctionTypeNode
+  | TypeLiteralNode
+  | ParenthesizedTypeNode
+  | TypeQueryNode
+  | IndexedAccessTypeNode
+  | TypeOperatorNode
+  | MappedTypeNode
+  | ConditionalTypeNode
+  | InferTypeNode
+  | OptionalTypeNode
+  | RestTypeNode;
+
+export interface SourceFileNode extends Node {
+  readonly kind: SyntaxKind.SourceFile;
+  readonly statements: Statement[];
+  readonly fileName: string;
+  readonly text: string;
+}

package/src/ast/declarations.ts

@@ -0,0 +1,130 @@
+/**
+ * Declaration nodes of the xbintsc AST (functions, classes, interfaces, ...).
+ */
+
+import { NodeFlags, SyntaxKind } from "./kinds.js";
+import type { Expression, Modifier, Node, TypeNode } from "./common.js";
+import type { Identifier, PropertyName, StringLiteral } from "./expressions.js";
+import type { Block } from "./statements.js";
+import type { TypeElement } from "./types.js";
+
+// ---------------------------------------------------------------------------
+// Declarations
+// ---------------------------------------------------------------------------
+
+export interface Parameter extends Node {
+  readonly kind: SyntaxKind.Parameter;
+  readonly name: Identifier;
+  readonly modifiers: Modifier[];
+  readonly dotDotDotToken: boolean;
+  readonly questionToken: boolean;
+  readonly type?: TypeNode;
+  readonly initializer?: Expression;
+}
+
+export interface TypeParameterDeclaration extends Node {
+  readonly kind: SyntaxKind.TypeParameterDeclaration;
+  readonly name: Identifier;
+  readonly constraint?: TypeNode;
+  readonly default?: TypeNode;
+}
+
+export interface FunctionDeclaration extends Node {
+  readonly kind: SyntaxKind.FunctionDeclaration;
+  readonly name?: Identifier;
+  readonly modifiers: Modifier[];
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly parameters: Parameter[];
+  readonly returnType?: TypeNode;
+  readonly body?: Block;
+  readonly flags: NodeFlags;
+}
+
+export interface HeritageClause extends Node {
+  readonly kind: SyntaxKind.HeritageClause;
+  readonly token: "extends" | "implements";
+  readonly types: ExpressionWithTypeArguments[];
+}
+
+export interface ExpressionWithTypeArguments extends Node {
+  readonly kind: SyntaxKind.ExpressionWithTypeArguments;
+  readonly expression: Expression;
+  readonly typeArguments: TypeNode[];
+}
+
+export type ClassElement = PropertyDeclaration | MethodDeclaration | ConstructorDeclaration;
+
+export interface PropertyDeclaration extends Node {
+  readonly kind: SyntaxKind.PropertyDeclaration;
+  readonly name: PropertyName;
+  readonly modifiers: Modifier[];
+  readonly questionToken: boolean;
+  readonly exclamationToken: boolean;
+  readonly type?: TypeNode;
+  readonly initializer?: Expression;
+}
+
+export interface MethodDeclaration extends Node {
+  readonly kind: SyntaxKind.MethodDeclaration;
+  readonly name: PropertyName;
+  readonly modifiers: Modifier[];
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly parameters: Parameter[];
+  readonly returnType?: TypeNode;
+  readonly body?: Block;
+  readonly flags: NodeFlags;
+  readonly optional: boolean;
+}
+
+export interface ConstructorDeclaration extends Node {
+  readonly kind: SyntaxKind.ConstructorDeclaration;
+  readonly modifiers: Modifier[];
+  readonly parameters: Parameter[];
+  readonly body?: Block;
+}
+
+export interface ClassDeclaration extends Node {
+  readonly kind: SyntaxKind.ClassDeclaration;
+  readonly name?: Identifier;
+  readonly modifiers: Modifier[];
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly heritage: HeritageClause[];
+  readonly members: ClassElement[];
+}
+
+export interface InterfaceDeclaration extends Node {
+  readonly kind: SyntaxKind.InterfaceDeclaration;
+  readonly name: Identifier;
+  readonly modifiers: Modifier[];
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly heritage: HeritageClause[];
+  readonly members: TypeElement[];
+}
+
+export interface TypeAliasDeclaration extends Node {
+  readonly kind: SyntaxKind.TypeAliasDeclaration;
+  readonly name: Identifier;
+  readonly modifiers: Modifier[];
+  readonly typeParameters: TypeParameterDeclaration[];
+  readonly type: TypeNode;
+}
+
+export interface EnumMember extends Node {
+  readonly kind: SyntaxKind.EnumMember;
+  readonly name: PropertyName;
+  readonly initializer?: Expression;
+}
+
+export interface EnumDeclaration extends Node {
+  readonly kind: SyntaxKind.EnumDeclaration;
+  readonly name: Identifier;
+  readonly modifiers: Modifier[];
+  readonly members: EnumMember[];
+}
+
+export interface ModuleDeclaration extends Node {
+  readonly kind: SyntaxKind.ModuleDeclaration;
+  readonly name: Identifier | StringLiteral;
+  readonly modifiers: Modifier[];
+  readonly body?: Block;
+}