xbintsc 0.5.6 → 0.5.21

package/src/driver/bundler/graph.ts

@@ -4,8 +4,8 @@
  */
 
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, extname } from "node:path";
-import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type Statement } from "../../ast/nodes.js";
+import { dirname, extname, relative } from "node:path";
+import { SyntaxKind, type ExportDeclaration, type ImportDeclaration, type NamedExports, type Statement } from "../../ast/nodes.js";
 import { bind } from "../../binder/binder.js";
 import { DiagnosticBag, DiagnosticCode } from "../../diagnostics/diagnostic.js";
 import { SourceFile } from "../../diagnostics/source.js";
@@ -16,12 +16,47 @@ import { classifyDependency } from "./resolve.js";
 import { collectRequireSites, isNodeModulesPath, usesCommonJS } from "./commonjs.js";
 import type { ModuleRecord } from "./types.js";
 
+/**
+ * True when an import has no runtime binding, so it is not a module edge:
+ * `import type { T } from "..."` or `import { type T } from "..."`. A
+ * side-effect-only import (`import "..."`) and an empty clause
+ * (`import {} from "..."`) both evaluate the module and *are* edges. Types are
+ * erased, so a type-only import must not pull the target into the bundle —
+ * and, in particular, must not turn the mutual `import type` references
+ * between source files into a circular-import error.
+ */
+function isTypeOnlyImport(declaration: ImportDeclaration): boolean {
+  const clause = declaration.importClause;
+  if (!clause) return false;
+  if (clause.isTypeOnly) return true;
+  if (clause.name) return false;
+  const bindings = clause.namedBindings;
+  if (!bindings) return true;
+  if (bindings.kind === SyntaxKind.NamespaceImport) return false;
+  // `import {} from "..."` is an empty clause but still evaluates the module.
+  return bindings.elements.length > 0 && bindings.elements.every((element) => element.isTypeOnly);
+}
+
+/** True when an export declaration only re-exports types. */
+function isTypeOnlyExport(declaration: ExportDeclaration): boolean {
+  if (declaration.isTypeOnly) return true;
+  const clause = declaration.exportClause;
+  if (!clause || clause.kind !== SyntaxKind.NamedExports) return false;
+  const elements = (clause as NamedExports).elements;
+  // `export {} from "..."` is a side-effect re-export, not a type-only one.
+  return elements.length > 0 && elements.every((element) => element.isTypeOnly);
+}
+
 function moduleSpecifierOf(statement: Statement): string | undefined {
   if (statement.kind === SyntaxKind.ImportDeclaration) {
-    return (statement as ImportDeclaration).moduleSpecifier.value;
+    const declaration = statement as ImportDeclaration;
+    if (isTypeOnlyImport(declaration)) return undefined;
+    return declaration.moduleSpecifier.value;
   }
   if (statement.kind === SyntaxKind.ExportDeclaration) {
-    const specifier = (statement as ExportDeclaration).moduleSpecifier;
+    const declaration = statement as ExportDeclaration;
+    if (isTypeOnlyExport(declaration)) return undefined;
+    const specifier = declaration.moduleSpecifier;
     if (specifier) return specifier.value;
   }
   return undefined;
@@ -36,15 +71,30 @@ export function loadGraph(
 ): ModuleRecord[] | undefined {
   const records = new Map<string, ModuleRecord>();
   const order: ModuleRecord[] = [];
-  const visiting = new Set<string>();
+  /* Modules on the current depth-first path, for cycle reporting. A module is
+   * added to `records` only after its dependencies finish, so a back edge is
+   * still "visiting" when it is reached. */
+  const stack: string[] = [];
   let counter = 0;
   let failed = false;
 
-  const load = (path: string): ModuleRecord | undefined => {
+  const load = (
+    path: string,
+    origin?: { readonly file: string; readonly statement: Statement },
+  ): ModuleRecord | undefined => {
     const existing = records.get(path);
     if (existing) return existing;
-    if (visiting.has(path)) {
-      diagnostics.error(DiagnosticCode.CodegenError, `Circular import detected involving '${path}'`);
+    if (stack.includes(path)) {
+      const start = stack.indexOf(path);
+      const cycle = [...stack.slice(start), path]
+        .map((entry) => relative(dirname(entryPath), entry))
+        .join(" -> ");
+      diagnostics.error(
+        DiagnosticCode.CircularDependency,
+        `Circular import detected: ${cycle}`,
+        origin?.statement,
+        origin?.file,
+      );
       failed = true;
       return undefined;
     }
@@ -53,7 +103,7 @@ export function loadGraph(
       failed = true;
       return undefined;
     }
-    visiting.add(path);
+    stack.push(path);
     const raw = sourceTextBytes(readFileSync(path, "utf8"));
     /* An extension may rewrite an imported asset (e.g. `.html`) into a TS
      * module before it is parsed. The core only sees the transformed text. */
@@ -68,7 +118,7 @@ export function loadGraph(
           error instanceof Error ? error.message : String(error),
         );
         failed = true;
-        visiting.delete(path);
+        stack.pop();
         return undefined;
       }
     }
@@ -90,7 +140,6 @@ export function loadGraph(
     // `require` / `module` / `exports` are only honoured inside `node_modules`,
     // so user code keeps its ESM-only diagnostic.
     record.commonjs = isNodeModulesPath(path) && usesCommonJS(bindResult);
-    records.set(path, record);
 
     for (const statement of sourceFile.statements) {
       const specifier = moduleSpecifierOf(statement);
@@ -107,7 +156,7 @@ export function loadGraph(
         failed = true;
         continue;
       }
-      load(dependency.path);
+      load(dependency.path, { file: path, statement });
     }
 
     // A CommonJS module's `require("...")` calls are dynamic import edges: the
@@ -118,7 +167,8 @@ export function loadGraph(
         if (dependency.kind === "file") load(dependency.path);
       }
     }
-    visiting.delete(path);
+    stack.pop();
+    records.set(path, record);
     order.push(record);
     return record;
   };

package/src/driver/bundler/merge.ts

@@ -77,8 +77,10 @@ export function bundleModules(
     for (const statement of record.sourceFile.statements) {
       if (statement.kind === SyntaxKind.ExportDeclaration) {
         const declaration = statement as ExportDeclaration;
+        if (declaration.isTypeOnly) continue;
         if (declaration.exportClause && declaration.exportClause.kind === SyntaxKind.NamedExports) {
           for (const specifier of declaration.exportClause.elements) {
+            if (specifier.isTypeOnly) continue;
             const localName = specifier.propertyName?.text ?? specifier.name.text;
             const exportedName = specifier.name.text;
             if (declaration.moduleSpecifier) {
@@ -144,7 +146,7 @@ export function bundleModules(
       const declaration = statement as ImportDeclaration;
       const dependency = dependencyOf(record, declaration.moduleSpecifier.value);
       const clause = declaration.importClause;
-      if (!clause || !dependency) continue;
+      if (!clause || clause.isTypeOnly || !dependency) continue;
       if (clause.name) {
         const target = dependency.exports.get("default") ?? dependency.exports.get("default");
         const local = scope.symbols.get(clause.name.text);
@@ -153,6 +155,7 @@ export function bundleModules(
       const bindings = clause.namedBindings;
       if (bindings && bindings.kind === SyntaxKind.NamedImports) {
         for (const specifier of bindings.elements) {
+          if (specifier.isTypeOnly) continue;
           const importedName = specifier.propertyName?.text ?? specifier.name.text;
           const target = dependency.exports.get(importedName);
           const local = scope.symbols.get(specifier.name.text);