xbintsc 0.3.79 → 0.3.87

package/src/codegen/generator/module.ts

@@ -29,9 +29,16 @@ function isParameterProperty(parameter: Parameter): boolean {
   );
 }
 
+/** A readable, IR-symbol-safe suffix for a function name. */
+function symbolSuffix(name: string): string {
+  if (name.length === 0 || name.startsWith("<")) return "";
+  return name.replace(/[^A-Za-z0-9_]/g, "_").replace(/^_+/, "").slice(0, 32);
+}
+
 export interface ModuleMethods {
   run(this: Generator): string;
   emitFunction(this: Generator, fn: FunctionInfo): void;
+  emitFunctionReturn(this: Generator, value: string): void;
   emitMain(this: Generator): void;
   functionName(this: Generator, fn: FunctionInfo): string;
   wrapAsync(this: Generator, value: string): string;
@@ -77,13 +84,32 @@ export const moduleMethods: ModuleMethods = {
     ];
     const runtimeDeclarations = new Set(RUNTIME_DECLARATIONS);
     const extraDeclarations = [...this.extraDeclarations].filter((line) => !runtimeDeclarations.has(line));
-    return [...header, ...RUNTIME_DECLARATIONS, ...extraDeclarations, "", ...this.globals, "", ...this.functions, ""].join("\n");
+    return [
+      ...header,
+      ...RUNTIME_DECLARATIONS,
+      ...extraDeclarations,
+      "",
+      ...this.globals,
+      "",
+      ...this.functions,
+      "",
+      ...this.debugMetadataLines(),
+    ].join("\n");
   },
 
   // -- module level --------------------------------------------------------
 
   emitFunction(fn: FunctionInfo): void {
+    this.unsupportedCount = 0;
+    // `async function*` would need an async iterator and a promise-returning
+    // `.next()`; the generator/async lowering below would silently produce a
+    // synchronous generator instead, so reject it rather than miscompile.
+    if (fn.isAsync && fn.isGenerator) {
+      this.unsupported(fn.node, "async generator function");
+      return;
+    }
     const name = this.functionName(fn);
+    const debugSubprogram = this.debugSubprogramFor(fn);
     const state: FunctionState = {
       fn,
       buffer: [],
@@ -98,10 +124,14 @@ export const moduleMethods: ModuleMethods = {
       finallyStack: [],
       escapePointers: [],
       usesTry: false,
+      trackFrames: !fn.isGenerator,
+      ...(debugSubprogram ? { debugSubprogram } : {}),
     };
     this.current = state;
+    if (debugSubprogram) this.setDebugLocation(fn.node);
 
-    const header = `define i64 @${name}(i64 %this, i64 %env, i32 %argc, i64* %argv) {`;
+    const debugSuffix = debugSubprogram ? ` !dbg ${debugSubprogram}` : "";
+    const header = `define i64 @${name}(i64 %this, i64 %env, i32 %argc, i64* %argv)${debugSuffix} {`;
     this.emit(`%saved.env = alloca i64`);
     this.emit(`store i64 %env, i64* %saved.env`);
     this.emit(`%saved.this = alloca i64`);
@@ -112,6 +142,23 @@ export const moduleMethods: ModuleMethods = {
     this.emit(`%saved.argv = alloca i64*`);
     this.emit(`store i64* %argv, i64** %saved.argv`);
 
+    // Shadow-stack frame: `Error.stack` and fatal-signal dumps walk this.
+    if (state.trackFrames) {
+      const displayName = fn.isModule
+        ? "module"
+        : fn.isConstructor && fn.classInfo
+          ? `new ${this.displayNameOf(fn.classInfo.name)}`
+          : this.displayNameOf(fn.name.length > 0 ? fn.name : "anonymous");
+      const namePointer = this.internStatic(displayName);
+      /* Normalise separators like `source_filename`: the compiler may run under
+       * Node (`\`) or as a self-hosted binary (`/`), and the IR must stay
+       * byte-identical across the two. */
+      const filePointer = this.internStatic(this.fileNameOf(fn.node).split("\\").join("/"));
+      this.emit(
+        `  call void @xt_stack_push(i8* ${namePointer}, i8* ${filePointer}, i32 ${this.lineOf(fn.node)})`,
+      );
+    }
+
     // Parameters.
     const parameterNodes = (fn.node as { parameters?: Parameter[] }).parameters ?? [];
     for (let index = 0; index < fn.params.length; index++) {
@@ -207,7 +254,7 @@ export const moduleMethods: ModuleMethods = {
       this.emitStatements(this.sourceFile.statements);
     } else if (fn.node.kind === SyntaxKind.ArrowFunction && (fn.node as ArrowFunction).body.kind !== SyntaxKind.Block) {
       const value = this.emitExpression((fn.node as ArrowFunction).body as Expression);
-      this.terminate(`ret i64 ${fn.isAsync ? this.wrapAsync(value) : value}`);
+      this.emitFunctionReturn(fn.isAsync ? this.wrapAsync(value) : value);
     } else {
       const body = (fn.node as { body: Block }).body;
       if (body) this.emitStatements(body.statements);
@@ -215,7 +262,7 @@ export const moduleMethods: ModuleMethods = {
 
     if (!this.current.terminated) {
       const fallback = fn.isAsync ? this.wrapAsync(i64(XT_UNDEFINED)) : i64(XT_UNDEFINED);
-      this.terminate(`ret i64 ${fallback}`);
+      this.emitFunctionReturn(fallback);
     }
 
     const escapes = state.usesTry
@@ -229,8 +276,22 @@ export const moduleMethods: ModuleMethods = {
     const moduleName = this.functionName(this.binding.moduleFunction);
     // Module bindings and class constructors live in globals; register them as
     // GC roots before the module body runs so a collection cannot free them.
-    const roots = [...this.classGlobals.values(), ...this.moduleGlobals.values()];
+    const stringEntries = [...this.strings.values()];
+    const roots = [
+      ...this.classGlobals.values(),
+      ...this.moduleGlobals.values(),
+      ...stringEntries.map((entry) => entry.slot),
+    ];
     const rootLines = roots.map((name) => `  call void @xt_gc_add_root(i64* ${name})`);
+    // Every interned string literal is materialised once here and shared by all
+    // uses, so property names and other literals stop allocating per access.
+    const stringInit = stringEntries.flatMap((entry) => {
+      const register = `%strv.${entry.slot.replace("@.strv.", "")}`;
+      return [
+        `  ${register} = call i64 @xt_string_new(i8* ${entry.label}, i64 ${entry.length})`,
+        `  store i64 ${register}, i64* ${entry.slot}`,
+      ];
+    });
     this.functions.push(
       [
         "define i32 @main(i32 %argc, i8** %argv) {",
@@ -239,6 +300,7 @@ export const moduleMethods: ModuleMethods = {
         "  call void @xt_gc_set_stack_base(i8* %stackbase.ptr)",
         "  call void @xt_gc_init()",
         ...rootLines,
+        ...stringInit,
         "  call void @xt_gc_arm()",
         "  call void @xt_set_program_args(i32 %argc, i8** %argv)",
         `  %result = call i64 @${moduleName}(i64 ${i64(XT_UNDEFINED)}, i64 ${i64(XT_UNDEFINED)}, i32 0, i64* null)`,
@@ -252,7 +314,17 @@ export const moduleMethods: ModuleMethods = {
   },
 
   functionName(fn: FunctionInfo): string {
-    return fn.isModule ? "xt_module" : `xt_fn_${fn.id}`;
+    if (fn.isModule) return "xt_module";
+    /* Keep the original name in the symbol so native debuggers, crash
+     * backtraces and `--emit ir` are readable (`xt_fn_3_sum`). */
+    const suffix = symbolSuffix(this.displayNameOf(fn.name));
+    return suffix.length > 0 ? `xt_fn_${fn.id}_${suffix}` : `xt_fn_${fn.id}`;
+  },
+
+  /** Emit the function's return, dropping its shadow-stack frame first. */
+  emitFunctionReturn(value: string): void {
+    if (this.current.trackFrames) this.emit("  call void @xt_stack_pop()");
+    this.terminate(`ret i64 ${value}`);
   },
 
   /** Wrap a returned value in a resolved promise (for `async` functions). */

package/src/codegen/generator/numeric.ts

@@ -0,0 +1,158 @@
+/**
+ * Inline fast paths for numeric operators.
+ *
+ * Every JavaScript operator used to be a runtime call (`xt_add`, `xt_lt`, …).
+ * That is correct but expensive in numeric code: a `for` loop paid three calls
+ * per iteration, and clang cannot inline across the generated IR / C runtime
+ * boundary. For two unboxed doubles the operation is just a hardware
+ * instruction, so emit that inline and keep the runtime call as the cold path
+ * for every other combination (strings, BigInt, coercion, …).
+ *
+ * Doubles are stored bit-for-bit in `xt_value`, so the tag check is an integer
+ * mask and the operation is `bitcast` → `fadd`/`fcmp` → `bitcast`.
+ */
+
+import { i64, XT_FALSE, XT_NUMBER_MASK, XT_TRUE } from "../values.js";
+import type { Generator } from "./generator.js";
+
+export interface NumericMethods {
+  /**
+   * Emit `left <operator> right`, using an inline double fast path when both
+   * operands turn out to be numbers and {@link allowFastPath} is set.
+   */
+  emitBinaryOperation(
+    this: Generator,
+    left: string,
+    right: string,
+    operator: string,
+    runtime: string,
+    allowFastPath?: boolean,
+  ): string;
+  emitNumericBinary(this: Generator, left: string, right: string, instruction: string, runtime: string): string;
+  emitNumericComparison(this: Generator, left: string, right: string, predicate: string, runtime: string): string;
+  /** Emit an i1 SSA value that is true when `value` is an unboxed double. */
+  isNumberValue(this: Generator, value: string): string;
+}
+
+/** Canonical quiet NaN; the runtime uses the same pattern in `xt_from_double`. */
+const CANONICAL_NAN = 0x7ff8000000000000n;
+
+const NUMERIC_ARITHMETIC: Record<string, string | undefined> = {
+  "+": "fadd",
+  "-": "fsub",
+  "*": "fmul",
+  "/": "fdiv",
+  "%": "frem",
+};
+
+const NUMERIC_COMPARISON: Record<string, string | undefined> = {
+  "<": "olt",
+  "<=": "ole",
+  ">": "ogt",
+  ">=": "oge",
+  "==": "oeq",
+  "!=": "une",
+  "===": "oeq",
+  "!==": "une",
+};
+
+export const numericMethods: NumericMethods = {
+  emitBinaryOperation(left, right, operator, runtime, allowFastPath = true) {
+    if (allowFastPath) {
+      const instruction = NUMERIC_ARITHMETIC[operator];
+      if (instruction) return this.emitNumericBinary(left, right, instruction, runtime);
+      const predicate = NUMERIC_COMPARISON[operator];
+      if (predicate) return this.emitNumericComparison(left, right, predicate, runtime);
+    }
+    const result = this.reg();
+    this.emit(`  ${result} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
+    return result;
+  },
+
+  /** Emit an i1 SSA value that is true when `value` is an unboxed double. */
+  isNumberValue(value: string): string {
+    const masked = this.reg();
+    this.emit(`  ${masked} = and i64 ${value}, ${i64(XT_NUMBER_MASK)}`);
+    const result = this.reg();
+    this.emit(`  ${result} = icmp ne i64 ${masked}, ${i64(XT_NUMBER_MASK)}`);
+    return result;
+  },
+
+  emitNumericBinary(left, right, instruction, runtime) {
+    const result = this.alloca();
+    const leftIsNumber = this.isNumberValue(left);
+    const rightIsNumber = this.isNumberValue(right);
+    const bothNumbers = this.reg();
+    this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
+    const fast = this.label("num.fast");
+    const slow = this.label("num.slow");
+    const end = this.label("num.end");
+    this.terminate(`br i1 ${bothNumbers}, label %${fast}, label %${slow}`);
+
+    this.startBlock(fast);
+    const leftDouble = this.reg();
+    this.emit(`  ${leftDouble} = bitcast i64 ${left} to double`);
+    const rightDouble = this.reg();
+    this.emit(`  ${rightDouble} = bitcast i64 ${right} to double`);
+    const computed = this.reg();
+    this.emit(`  ${computed} = ${instruction} double ${leftDouble}, ${rightDouble}`);
+    // Hardware NaNs carry many payloads; the value model only reserves the
+    // canonical quiet NaN, and `-NaN` would otherwise collide with XT_UNDEFINED.
+    const bits = this.reg();
+    this.emit(`  ${bits} = bitcast double ${computed} to i64`);
+    const unordered = this.reg();
+    this.emit(`  ${unordered} = fcmp uno double ${computed}, ${computed}`);
+    const canonical = this.reg();
+    this.emit(`  ${canonical} = select i1 ${unordered}, i64 ${i64(CANONICAL_NAN)}, i64 ${bits}`);
+    this.emit(`  store i64 ${canonical}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(slow);
+    const called = this.reg();
+    this.emit(`  ${called} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
+    this.emit(`  store i64 ${called}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(end);
+    const value = this.reg();
+    this.emit(`  ${value} = load i64, i64* ${result}`);
+    return value;
+  },
+
+  emitNumericComparison(left, right, predicate, runtime) {
+    const result = this.alloca();
+    const leftIsNumber = this.isNumberValue(left);
+    const rightIsNumber = this.isNumberValue(right);
+    const bothNumbers = this.reg();
+    this.emit(`  ${bothNumbers} = and i1 ${leftIsNumber}, ${rightIsNumber}`);
+    const fast = this.label("cmp.fast");
+    const slow = this.label("cmp.slow");
+    const end = this.label("cmp.end");
+    this.terminate(`br i1 ${bothNumbers}, label %${fast}, label %${slow}`);
+
+    this.startBlock(fast);
+    const leftDouble = this.reg();
+    this.emit(`  ${leftDouble} = bitcast i64 ${left} to double`);
+    const rightDouble = this.reg();
+    this.emit(`  ${rightDouble} = bitcast i64 ${right} to double`);
+    // Ordered comparisons are false for NaN and unordered `!=` is true, which
+    // is exactly ECMAScript's behaviour for two numbers.
+    const compared = this.reg();
+    this.emit(`  ${compared} = fcmp ${predicate} double ${leftDouble}, ${rightDouble}`);
+    const value = this.reg();
+    this.emit(`  ${value} = select i1 ${compared}, i64 ${i64(XT_TRUE)}, i64 ${i64(XT_FALSE)}`);
+    this.emit(`  store i64 ${value}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(slow);
+    const called = this.reg();
+    this.emit(`  ${called} = call i64 @${runtime}(i64 ${left}, i64 ${right})`);
+    this.emit(`  store i64 ${called}, i64* ${result}`);
+    this.terminate(`br label %${end}`);
+
+    this.startBlock(end);
+    const merged = this.reg();
+    this.emit(`  ${merged} = load i64, i64* ${result}`);
+    return merged;
+  },
+};

package/src/codegen/generator/state.ts

@@ -50,6 +50,16 @@ export interface FunctionState {
   thisPtr?: string;
   /** Set when the function contains a `try`, forcing locals to live in memory. */
   usesTry: boolean;
+  /**
+   * True when the function pushes/pops a shadow-stack frame. Generator bodies
+   * are excluded: they switch stacks and can be suspended, so a global shadow
+   * stack would attribute their frames to the wrong caller.
+   */
+  trackFrames: boolean;
+  /** `!DISubprogram` for this function when DWARF emission is enabled. */
+  debugSubprogram?: string;
+  /** Current `!DILocation` attached to every emitted instruction. */
+  debugLocation?: string;
 }
 
 export interface CodegenResult {
@@ -74,6 +84,13 @@ export interface CodegenOptions {
    * defaults to the running process; it is overridable for tests.
    */
   readonly target?: { readonly platform: string; readonly arch: string };
+  /**
+   * Emit LLVM debug metadata (`!DICompileUnit`, `!DISubprogram`,
+   * `!DILocation`) so `clang -g` produces DWARF/CodeView for the generated
+   * program. Off by default: the metadata is large and only useful when
+   * debugging; `xbintsc build --debug` turns it on.
+   */
+  readonly debug?: boolean;
 }
 
 export const RUNTIME_DECLARATIONS: readonly string[] = [
@@ -93,6 +110,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_this()",
   "declare i64 @xt_new(i64, i32, i64*)",
   "declare i64 @xt_instance_of(i64, i64)",
+  "declare i64 @xt_instance_of_builtin(i64, i32)",
   "declare i64 @xt_function_set_prototype(i64, i64)",
   "declare i64 @xt_function_get_prototype(i64)",
   "declare i64 @xt_object_new_with_proto(i64)",
@@ -225,6 +243,7 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i64 @xt_object_entries(i64)",
   "declare i64 @xt_object_assign(i32, i64*)",
   "declare i64 @xt_object_spread(i64, i64)",
+  "declare i64 @xt_object_rest(i64, i32, i64*)",
   "declare i64 @xt_call_method(i64, i64, i32, i64*)",
   "declare i64 @xt_math_call(i64, i32, i64*)",
   "declare i64 @xt_parse_int(i32, i64*)",
@@ -298,6 +317,9 @@ export const RUNTIME_DECLARATIONS: readonly string[] = [
   "declare i8* @xt_try_enter()",
   "declare i64 @xt_try_exception(i8*)",
   "declare void @xt_try_leave(i8*)",
+  "declare void @xt_stack_push(i8*, i8*, i32)",
+  "declare void @xt_stack_pop()",
+  "declare void @xt_stack_set_line(i32)",
   "declare void @xt_console_log(i32, i64*)",
   "declare void @xt_console_info(i32, i64*)",
   "declare void @xt_console_warn(i32, i64*)",

package/src/codegen/generator/statements/control-flow.ts

@@ -255,7 +255,7 @@ export const controlFlowStatementMethods: ControlFlowStatementMethods = {
     this.runFinallysBeforeExit(0);
     if (this.current.terminated) return;
     this.popTryFramesTo(0);
-    this.terminate(`ret i64 ${value}`);
+    this.emitFunctionReturn(value);
   },
 
   /** Emit `xt_try_leave` for every active frame above `depth` (innermost first). */

package/src/codegen/generator/statements/dispatch.ts

@@ -41,6 +41,9 @@ export const statementDispatchMethods: StatementDispatchMethods = {
   },
 
   emitStatement(statement: Statement): void {
+    /* Every instruction emitted while lowering this statement (including
+     * nested expressions) points at its source position when DWARF is on. */
+    this.setDebugLocation(statement);
     switch (statement.kind) {
       case SyntaxKind.ExpressionStatement:
         this.emitExpression((statement as { expression: Expression }).expression);

package/src/codegen/generator/statements/variables.ts

@@ -87,13 +87,19 @@ export const variableStatementMethods: VariableStatementMethods = {
       return;
     }
     const pattern = name as ObjectBindingPattern;
+    /* Keys named by the pattern are excluded from `...rest`. */
+    const excludedKeys: string[] = [];
     for (const element of pattern.elements) {
-      const key = element.propertyName ?? (element.name.kind === SyntaxKind.Identifier ? element.name : undefined);
       if (element.dotDotDotToken) {
-        this.unsupported(element, "object rest destructuring");
+        const rest = this.reg();
+        const keys = this.emitValueArguments(excludedKeys);
+        this.emit(`  ${rest} = call i64 @xt_object_rest(i64 ${value}, i32 ${keys.argc}, i64* ${keys.ptr})`);
+        this.emitBindingPattern(element.name, rest);
         continue;
       }
+      const key = element.propertyName ?? (element.name.kind === SyntaxKind.Identifier ? element.name : undefined);
       const keyValue = this.stringValue(key ? propertyNameText(key) : "undefined");
+      excludedKeys.push(keyValue);
       let elementValue = this.reg();
       this.emit(`  ${elementValue} = call i64 @xt_get(i64 ${value}, i64 ${keyValue})`);
       if (element.initializer) elementValue = this.emitBindingDefault(elementValue, element.initializer);

package/src/codegen/generator/tables.ts

@@ -22,6 +22,32 @@ export function requiresSetjmpex(platform: string, arch: string): boolean {
   return platform === "win32" && arch === "arm64";
 }
 
+/**
+ * Built-in constructors usable on the right of `instanceof`, mapped to the id
+ * `xt_instance_of_builtin` expects. Keep in sync with the `XT_INSTANCE_*` enum
+ * in `runtime/xt_builtins.c`; the typed-array ids follow the runtime's
+ * `XT_TA_*` order (Uint8Array first).
+ */
+export const BUILTIN_INSTANCEOF: Readonly<Record<string, number>> = {
+  Array: 0,
+  Object: 1,
+  Function: 2,
+  Map: 3,
+  Set: 4,
+  Date: 5,
+  RegExp: 6,
+  Promise: 7,
+  Uint8Array: 16,
+  Int8Array: 17,
+  Uint8ClampedArray: 18,
+  Uint16Array: 19,
+  Int16Array: 20,
+  Uint32Array: 21,
+  Int32Array: 22,
+  Float32Array: 23,
+  Float64Array: 24,
+};
+
 export const BINARY_RUNTIME: Record<string, string | undefined> = {
   [BinaryOperator.Add]: "xt_add",
   [BinaryOperator.Subtract]: "xt_sub",

package/src/driver/bundler/merge.ts

@@ -169,6 +169,32 @@ export function bundleModules(
 
   // Phase 4: concatenate statements, dropping imports and pure export wrappers.
   const merged: Statement[] = [];
+  /* Every node keeps the module it was parsed from, so a later codegen
+   * diagnostic can name the right file and line instead of pointing into the
+   * entry module (whose text happens to start at the same offsets). */
+  const origins = new Map<object, string>();
+  const trackOrigin = (record: ModuleRecord, root: Node): void => {
+    const visit = (node: Node): void => {
+      origins.set(node, record.path);
+      const fields = node as unknown as Record<string, unknown>;
+      for (const key of Object.keys(fields)) {
+        if (key === "kind" || key === "start" || key === "end" || key === "text" || key === "value" || key === "raw") {
+          continue;
+        }
+        const value = fields[key];
+        if (Array.isArray(value)) {
+          for (const child of value) if (isNode(child)) visit(child);
+        } else if (isNode(value)) {
+          visit(value);
+        }
+      }
+    };
+    visit(root);
+  };
+  const push = (record: ModuleRecord, statement: Statement): void => {
+    trackOrigin(record, statement);
+    merged.push(statement);
+  };
   const first = records[records.length - 1]!;
   for (const record of records) {
     for (const statement of record.sourceFile.statements) {
@@ -181,25 +207,25 @@ export function bundleModules(
           externalSpecifiers,
         );
         if (resolution.kind === "external") {
-          merged.push(statement);
+          push(record, statement);
         } else {
           const synthetic = namespaceStatements.get(statement);
-          if (synthetic) merged.push(synthetic);
+          if (synthetic) push(record, synthetic);
         }
         continue;
       }
       if (statement.kind === SyntaxKind.ExportDeclaration) {
         const declaration = statement as ExportDeclaration;
         const inner = (declaration as unknown as { declaration?: Statement }).declaration;
-        if (inner) merged.push(inner);
+        if (inner) push(record, inner);
         continue;
       }
       if (statement.kind === SyntaxKind.ExportAssignment) {
         const assignment = statement as ExportAssignment;
-        merged.push(exportAssignmentToStatement(record, assignment));
+        push(record, exportAssignmentToStatement(record, assignment));
         continue;
       }
-      merged.push(statement);
+      push(record, statement);
     }
   }
 
@@ -217,6 +243,9 @@ export function bundleModules(
     kind: SyntaxKind.SourceFile,
     statements: merged,
     fileName: first.path,
+    origins,
+    moduleTexts: new Map(records.map((record) => [record.path, record.text])),
+    modulePrefixes: records.map((record) => record.prefix),
     text: records.map((record) => record.text).join("\n"),
     start: 0,
     end: 0,
@@ -248,6 +277,11 @@ function collectBindingIdentifiers(name: BindingName, out: string[]): void {
   }
 }
 
+/** True for anything shaped like an AST node (constructed nodes carry no trivia). */
+function isNode(value: unknown): value is Node {
+  return !!value && typeof value === "object" && "kind" in (value as object);
+}
+
 /** Lower `import * as ns from "./mod"` to `const m0_ns = { ...exports }`. */
 function namespaceImportToStatement(
   statement: Statement,