xbintsc 0.3.3 → 0.3.5

package/src/driver/modules.ts

@@ -6,9 +6,10 @@
  * Each module's top-level bindings are renamed to a globally unique name and
  * imported names are rewritten to the (renamed) exported binding.
  *
- * This is intentionally simple: it supports named imports/exports, `export
- * default` for declarations, and `export ... from`. Namespace imports and
- * `export *` are approximated, and circular graphs are reported as an error.
+ * This is intentionally simple: it supports named imports/exports, namespace
+ * imports, `export default` for declarations, `export ... from` and `export *`.
+ * Namespace names are live bindings only at the granularity of the module's
+ * final names, and circular graphs are reported as an error.
  */
 
 import { existsSync, readFileSync, statSync } from "node:fs";
@@ -21,6 +22,8 @@ import {
   type Identifier,
   type ImportDeclaration,
   type Node,
+  type ObjectLiteralExpression,
+  type PropertyAssignment,
   type SourceFileNode,
   type Statement,
   type VariableDeclaration,
@@ -284,7 +287,10 @@ export function bundleModules(entryPath: string, diagnostics: DiagnosticBag): Bu
     }
   }
 
-  // Phase 3: rewrite imported names and record re-exports.
+  // Phase 3: rewrite imported names and record re-exports. Namespace imports
+  // are lowered to a synthetic object literal holding every export, built
+  // from the dependency's (already renamed) final names.
+  const namespaceStatements = new Map<Statement, Statement>();
   for (const record of records) {
     const scope = moduleScope(record);
     if (!scope) continue;
@@ -307,6 +313,11 @@ export function bundleModules(entryPath: string, diagnostics: DiagnosticBag): Bu
           const local = scope.symbols.get(specifier.name.text);
           if (target && local) renameReferences(local, target);
         }
+      } else if (bindings && bindings.kind === SyntaxKind.NamespaceImport) {
+        const local = scope.symbols.get(bindings.name.text);
+        const finalName = `${record.prefix}${bindings.name.text}`;
+        if (local) renameReferences(local, finalName);
+        namespaceStatements.set(statement, namespaceImportToStatement(statement, finalName, dependency));
       }
     }
   }
@@ -320,6 +331,9 @@ export function bundleModules(entryPath: string, diagnostics: DiagnosticBag): Bu
         // External (extension) imports stay in place for code generation.
         if (isExternalSpecifier((statement as ImportDeclaration).moduleSpecifier.value)) {
           merged.push(statement);
+        } else {
+          const synthetic = namespaceStatements.get(statement);
+          if (synthetic) merged.push(synthetic);
         }
         continue;
       }
@@ -383,6 +397,52 @@ function collectBindingIdentifiers(name: import("../ast/declarations.js").Bindin
   }
 }
 
+/** Lower `import * as ns from "./mod"` to `const m0_ns = { ...exports }`. */
+function namespaceImportToStatement(
+  statement: Statement,
+  finalName: string,
+  dependency: ModuleRecord,
+): Statement {
+  const properties: PropertyAssignment[] = [];
+  for (const [exportedName, target] of dependency.exports) {
+    properties.push({
+      kind: SyntaxKind.PropertyAssignment,
+      name: { kind: SyntaxKind.Identifier, text: exportedName, start: statement.start, end: statement.start },
+      initializer: { kind: SyntaxKind.Identifier, text: target, start: statement.start, end: statement.start },
+      start: statement.start,
+      end: statement.start,
+    });
+  }
+  const initializer: ObjectLiteralExpression = {
+    kind: SyntaxKind.ObjectLiteralExpression,
+    properties,
+    start: statement.start,
+    end: statement.end,
+  };
+  const declaration: VariableDeclaration = {
+    kind: SyntaxKind.VariableDeclaration,
+    name: { kind: SyntaxKind.Identifier, text: finalName, start: statement.start, end: statement.start },
+    exclamation: false,
+    initializer,
+    start: statement.start,
+    end: statement.end,
+  };
+  const list: VariableDeclarationList = {
+    kind: SyntaxKind.VariableDeclarationList,
+    declarationKind: "const" as const,
+    declarations: [declaration],
+    start: statement.start,
+    end: statement.end,
+  };
+  return {
+    kind: SyntaxKind.VariableStatement,
+    declarationList: list,
+    modifiers: [],
+    start: statement.start,
+    end: statement.end,
+  };
+}
+
 /** Turn `export default expr` into a synthetic `const` declaration. */
 function exportAssignmentToStatement(record: ModuleRecord, assignment: ExportAssignment): Statement {
   const name: Identifier = {

package/src/driver/toolchain.ts

@@ -114,7 +114,7 @@ export function compileC(
 ): void {
   const result = runner.run(
     clang,
-    ["-O2", "-D_CRT_SECURE_NO_WARNINGS", "-c", sourcePath, "-o", objectPath, `-I${includeDir}`],
+    ["-O2", "-Wall", "-Wextra", "-D_CRT_SECURE_NO_WARNINGS", "-c", sourcePath, "-o", objectPath, `-I${includeDir}`],
     { env },
   );
   if (result.status !== 0) throw new ToolchainError(`${clang} ${sourcePath}`, result.status, result.stderr);

package/src/lexer/scanner.ts

@@ -168,7 +168,6 @@ export class Scanner {
   }
 }
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface Scanner
   extends IdentifierMethods,
     NumberMethods,

package/src/parser/declarations/classes.ts

@@ -196,6 +196,10 @@ export const declarationClassMethods: DeclarationClassMethods = {
 
   parsePropertyName(this: Parser): PropertyName {
     const token = this.token;
+    if (token.kind === TokenKind.PrivateIdentifier) {
+      this.nextToken();
+      return { kind: SyntaxKind.PrivateIdentifier, text: token.text, start: token.start, end: token.end };
+    }
     if (token.kind === TokenKind.StringLiteral) {
       this.nextToken();
       return { kind: SyntaxKind.StringLiteral, text: token.text, raw: token.text, value: String(token.value ?? ""), start: token.start, end: token.end };

package/src/parser/declarations/type-members.ts

@@ -11,13 +11,11 @@ import {
   type EnumMember,
   type Expression,
   type Identifier,
-  type IndexSignature,
   type InterfaceDeclaration,
   type MethodSignature,
   type Modifier,
   type ModuleDeclaration,
   type Parameter,
-  type PropertyName,
   type PropertySignature,
   type StringLiteral,
   type TypeAliasDeclaration,

package/src/parser/expressions.ts

@@ -19,6 +19,7 @@ import {
   type CallExpression,
   type ConditionalExpression,
   type Expression,
+  type Identifier,
   type NewExpression,
   type NumericLiteral,
   type Parameter,
@@ -54,6 +55,7 @@ export interface ExpressionMethods {
   parseCallAndMemberTail(this: Parser, base: Expression): Expression;
   previousEnd(this: Parser, args: readonly Expression[], fallback: number): number;
   parsePropertyAccess(this: Parser, expression: Expression): Expression;
+  parseMemberName(this: Parser): Identifier;
   parseArguments(this: Parser): Expression[];
 }
 
@@ -459,10 +461,20 @@ export const expressionMethods: ExpressionMethods = {
       const close = this.parseExpected(TokenKind.CloseBracket);
       return { kind: SyntaxKind.ElementAccessExpression, expression, argumentExpression: argument, optional: true, start: expression.start, end: close.end };
     }
-    const name = this.parseIdentifierName();
+    const name = this.parseMemberName();
     return { kind: SyntaxKind.PropertyAccessExpression, expression, name, optional, start: expression.start, end: name.end };
   },
 
+  /** Member name after `.`: a normal identifier or a `#private` name. */
+  parseMemberName(this: Parser): Identifier {
+    const token = this.token;
+    if (token.kind === TokenKind.PrivateIdentifier) {
+      this.nextToken();
+      return { kind: SyntaxKind.Identifier, text: token.text, escaped: true, start: token.start, end: token.end };
+    }
+    return this.parseIdentifierName();
+  },
+
   parseArguments(this: Parser): Expression[] {
     this.parseExpected(TokenKind.OpenParen);
     const args: Expression[] = [];

package/src/parser/helpers.ts

@@ -36,12 +36,12 @@ export function propertyNameText(name: PropertyName): string {
 
 export function isAssignmentTarget(expr: Expression): boolean {
   switch (expr.kind) {
+    // Array/object literals are valid on the left of `=` as destructuring
+    // patterns (`[a, b] = xs`, `({ a } = obj)`).
     case SyntaxKind.Identifier:
     case SyntaxKind.PropertyAccessExpression:
     case SyntaxKind.ElementAccessExpression:
     case SyntaxKind.ParenthesizedExpression:
-    // Array/object literals are valid on the left of `=` as destructuring
-    // patterns (`[a, b] = xs`, `({ a } = obj)`).
     case SyntaxKind.ArrayLiteralExpression:
     case SyntaxKind.ObjectLiteralExpression:
       return true;

package/src/parser/literals.ts

@@ -33,6 +33,12 @@ export interface LiteralMethods {
   parseRegularExpression(this: Parser): RegularExpressionLiteral;
 }
 
+/** Strip the delimiters from a scanned template chunk and normalize newlines. */
+function rawTemplateChunk(text: string, leading: number, trailing: number): string {
+  const end = Math.max(leading, text.length - trailing);
+  return text.slice(leading, end).replace(/\r\n?/g, "\n");
+}
+
 export const literalMethods: LiteralMethods = {
   parseArrayLiteral(this: Parser): ArrayLiteralExpression {
     const open = this.parseExpected(TokenKind.OpenBracket);
@@ -66,6 +72,50 @@ export const literalMethods: LiteralMethods = {
         const start = this.nextToken().start;
         const expression = this.parseAssignmentExpression();
         properties.push({ kind: SyntaxKind.SpreadElement, expression, start, end: expression.end });
+      } else if (
+        (this.at(TokenKind.GetKeyword) || this.at(TokenKind.SetKeyword)) &&
+        !this.atAhead(1, TokenKind.OpenParen) &&
+        !this.atAhead(1, TokenKind.Colon) &&
+        !this.atAhead(1, TokenKind.Comma) &&
+        !this.atAhead(1, TokenKind.CloseBrace) &&
+        !this.atAhead(1, TokenKind.Equals) &&
+        !this.atAhead(1, TokenKind.Question) &&
+        !this.atAhead(1, TokenKind.LessThan)
+      ) {
+        // `{ get x() {} }` / `{ set x(v) {} }` object-literal accessors.
+        const start = this.token.start;
+        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();
+        }
+        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,
+          accessor: accessorToken.kind === TokenKind.GetKeyword ? "get" : "set",
+          start,
+          end: body.end,
+        });
+      } else if (this.at(TokenKind.Asterisk)) {
+        // `{ *gen() {} }` object-literal generator method.
+        const start = this.nextToken().start;
+        const name = this.parsePropertyName();
+        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.Generator, start, end: body.end };
+        properties.push({ kind: SyntaxKind.PropertyAssignment, name, initializer: fn, start, end: body.end });
       } else {
         const start = this.token.start;
         const name = this.parsePropertyName();
@@ -142,7 +192,14 @@ export const literalMethods: LiteralMethods = {
     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;
+      return {
+        kind: SyntaxKind.NoSubstitutionTemplateLiteral,
+        text: startToken.text,
+        value: String(startToken.value ?? ""),
+        raw: rawTemplateChunk(startToken.text, 1, 1),
+        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.
@@ -150,14 +207,16 @@ export const literalMethods: LiteralMethods = {
       this.tokens = [this.scanner.nextToken()];
       this.index = 0;
       return this.parseTemplateLiteral();
-    }    const head = String(startToken.value ?? "");
+    }
+    const head = String(startToken.value ?? "");
+    const headRaw = rawTemplateChunk(startToken.text, 1, 2);
     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 };
+        return { kind: SyntaxKind.TemplateLiteral, head, raw: headRaw, 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.
@@ -167,16 +226,32 @@ export const literalMethods: LiteralMethods = {
       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 };
+        spans.push({
+          kind: SyntaxKind.TemplateSpan,
+          expression,
+          literal: String(literalToken.value ?? ""),
+          raw: rawTemplateChunk(literalToken.text, 0, 1),
+          isTail: true,
+          start: expression.start,
+          end: literalToken.end,
+        });
+        return { kind: SyntaxKind.TemplateLiteral, head, raw: headRaw, 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 });
+        spans.push({
+          kind: SyntaxKind.TemplateSpan,
+          expression,
+          literal: String(literalToken.value ?? ""),
+          raw: rawTemplateChunk(literalToken.text, 0, 2),
+          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 };
+      return { kind: SyntaxKind.TemplateLiteral, head, raw: headRaw, spans, start: startToken.start, end: literalToken.end };
     }
   },
 

package/src/parser/modules.ts

@@ -13,7 +13,6 @@ import {
   type ImportClause,
   type ImportDeclaration,
   type ImportSpecifier,
-  type Modifier,
   type NamedExports,
   type NamedImports,
   type NamespaceImport,

package/src/parser/parser.ts

@@ -24,7 +24,6 @@ export class Parser extends ParserContext {
     const statements: Statement[] = [];
     while (!this.at(TokenKind.EndOfFile)) {
       const before = this.consumed;
-      const beforePos = this.scanner.position;
       const statement = this.parseStatement();
       if (statement) statements.push(statement);
       if (this.consumed === before) {

package/src/parser/statements.ts

@@ -43,6 +43,7 @@ export interface StatementMethods {
   parseDoStatement(this: Parser): Statement;
   parseForStatement(this: Parser): ForStatement | ForOfStatement | ForInStatement;
   parseReturnStatement(this: Parser): Statement;
+  parseLabeledStatement(this: Parser): Statement;
   parseBreakStatement(this: Parser): Statement;
   parseContinueStatement(this: Parser): Statement;
   parseThrowStatement(this: Parser): Statement;
@@ -60,6 +61,8 @@ export const statementMethods: StatementMethods = {
       const kind = this.token.kind;
       const nextKind = this.lookAhead(1).kind;
       const nextStartsName =
+        nextKind === TokenKind.Identifier ||
+        nextKind === TokenKind.PrivateIdentifier ||
         isIdentifierNameToken(nextKind) ||
         isKeywordKind(nextKind) ||
         nextKind === TokenKind.OpenBracket ||
@@ -126,6 +129,9 @@ export const statementMethods: StatementMethods = {
 
   parseStatement(this: Parser): Statement | undefined {
     const token = this.token;
+    if (this.isIdentifierLike(token) && this.atAhead(1, TokenKind.Colon)) {
+      return this.parseLabeledStatement();
+    }
     switch (token.kind) {
       case TokenKind.OpenBrace:
         return this.parseBlock();
@@ -381,6 +387,14 @@ export const statementMethods: StatementMethods = {
     return { kind: SyntaxKind.ReturnStatement, expression, start, end: expression?.end ?? start + 6 } as Statement;
   },
 
+  parseLabeledStatement(this: Parser): Statement {
+    const label = this.parseIdentifier();
+    this.parseExpected(TokenKind.Colon);
+    const statement = this.parseStatement();
+    const node = statement ?? ({ kind: SyntaxKind.EmptyStatement, start: label.end, end: label.end } as Statement);
+    return { kind: SyntaxKind.LabeledStatement, label, statement: node, start: label.start, end: node.end } as Statement;
+  },
+
   parseBreakStatement(this: Parser): Statement {
     const start = this.parseExpected(TokenKind.BreakKeyword).start;
     let label: Identifier | undefined;

package/src/parser/types.ts

@@ -330,13 +330,13 @@ export const typeMethods: TypeMethods = {
     if (this.atAhead(1, TokenKind.OpenBracket)) {
       cursor = 1;
       if (this.atAhead(2, TokenKind.Identifier)) {
-        let i = 3;
+        const i = 3;
         if (this.lookAhead(i).kind === TokenKind.InKeyword) {
           const open = this.parseExpected(TokenKind.OpenBrace);
           this.parseExpected(TokenKind.OpenBracket);
           const name = this.parseIdentifier();
           this.parseExpected(TokenKind.InKeyword);
-          let constraint = this.parseType();
+          const constraint = this.parseType();
           this.parseExpected(TokenKind.CloseBracket);
           let questionToken: boolean | "+" | "-" = false;
           if (this.at(TokenKind.Question)) {