bundler: run no macro in a bundle made only for its import graph (test --changed, --analyze, bun create <component>)

docs/bundler/macros.mdx

@@ -116,6 +116,8 @@ Macros run synchronously in the transpiler during the visiting phase, after the
 
 Bun's bundler is multi-threaded, so macros execute in parallel in multiple spawned JavaScript "workers".
 
+`bun test --changed`, `bun install --analyze`, `bun add --analyze` and `bun create <component>` first scan your files to find what they import. That scan does not run macros. It follows a macro import to its file like an ordinary import, and it does not see an `import()` or a `require()` whose specifier is the result of a macro. Macros still run afterwards, when the selected tests or the generated project run.
+
 ## Dead code elimination
 
 The bundler performs dead code elimination after running and inlining macros. Given the following macro:

src/bundler/ParseTask.rs

@@ -2548,6 +2548,7 @@ pub mod parse_worker {
             || !(task.experimental_decorators || task.emit_decorator_metadata);
         opts.features.unwrap_commonjs_packages = topts.unwrap_commonjs_packages;
         opts.features.no_macros = topts.no_macros;
+        opts.features.macro_imports_are_plain = worker_ctx.scan_only;
         // Modeled as
         // `Option<Box<StringSet>>` on both sides, so we deep-clone (small —
         // CLI-supplied flag set). PERF: retype

src/bundler/bundle_v2.rs

@@ -132,6 +132,9 @@ pub struct BundleV2<'a> {
     /// If false we can skip TLA validation and propagation.
     pub(crate) has_any_top_level_await_modules: bool,
 
+    /// No code is printed: the caller reads the graph of the bundle (its files, imports and exports).
+    pub(crate) scan_only: bool,
+
     /// Barrel optimization: tracks which exports have been requested from each
     /// module encountered during barrel BFS. Keys are source indices. Values
     /// track requested export names for deduplication and cycle detection.
@@ -3314,6 +3317,7 @@ pub mod bv2_impl {
                 drain_defer_task: DeferredBatchTask::default(),
                 asynchronous: false,
                 has_any_top_level_await_modules: false,
+                scan_only: false,
                 requested_exports: Vec::new(),
             });
             if let Some(bo) = bake_options {
@@ -4457,6 +4461,7 @@ pub mod bv2_impl {
                 alloc,
             )?;
             this.unique_key = generate_unique_key();
+            this.scan_only = fetcher.is_some();
 
             // Wrap so every exit path (incl. `?`) hits the cleanup below.
             let result = (|| -> Result<BuildResult, Error> {
@@ -4596,6 +4601,7 @@ pub mod bv2_impl {
         ) -> Result<Box<BundleV2<'a>>, Error> {
             let mut this = BundleV2::init(transpiler, None, alloc, event_loop, false, None, alloc)?;
             this.unique_key = generate_unique_key();
+            this.scan_only = true;
 
             if this.transpiler.log().has_errors() {
                 return Err(crate::Error::BuildFailed);

src/js_parser/p.rs

@@ -4109,12 +4109,20 @@ impl<'a, const TYPESCRIPT: bool, const SCAN_ONLY: bool> P<'a, TYPESCRIPT, SCAN_O
     pub(crate) fn process_import_statement(
         &mut self,
         stmt_: S::Import,
-        path: ParsedPath<'a>,
+        mut path: ParsedPath<'a>,
         loc: bun_ast::Loc,
         was_originally_bare_import: bool,
     ) -> Result<Stmt, crate::Error> {
-        let is_macro =
+        let mut is_macro =
             Self::ALLOW_MACROS && (path.is_macro || crate::Macro::is_macro_path(path.text));
+        if is_macro && self.options.features.macro_imports_are_plain {
+            // `MacroContext::call` resolves the path without the `macro:` prefix, so the ordinary import gets that path.
+            path.text = path
+                .text
+                .strip_prefix(crate::Macro::NAMESPACE_WITH_COLON)
+                .unwrap_or(path.text);
+            is_macro = false;
+        }
         let mut stmt = stmt_;
         if is_macro {
             let id = self.add_import_record(ImportKind::Stmt, path.loc, path.text);

src/js_parser/parse/parse_entry.rs

@@ -278,6 +278,7 @@ impl<'a> Options<'a> {
                 inlining: f.inlining,
                 inject_jest_globals: f.inject_jest_globals,
                 no_macros: f.no_macros,
+                macro_imports_are_plain: f.macro_imports_are_plain,
                 commonjs_named_exports: f.commonjs_named_exports,
                 minify_syntax: f.minify_syntax,
                 minify_identifiers: f.minify_identifiers,

src/js_parser/parser.rs

@@ -194,6 +194,8 @@ pub mod Runtime {
         pub inject_jest_globals: bool,
 
         pub no_macros: bool,
+        /// A macro import is an ordinary import, and no macro runs. The output is then not what the program means.
+        pub macro_imports_are_plain: bool,
 
         pub commonjs_named_exports: bool,
 
@@ -286,6 +288,7 @@ pub mod Runtime {
                 inlining: false,
                 inject_jest_globals: false,
                 no_macros: false,
+                macro_imports_are_plain: false,
                 commonjs_named_exports: true,
                 minify_syntax: false,
                 minify_identifiers: false,
@@ -357,6 +360,7 @@ pub mod Runtime {
         // Takes `Wyhash` (NOT `Wyhash11`).
         pub(crate) fn hash_for_runtime_transpiler(&self, hasher: &mut Wyhash) {
             debug_assert!(self.runtime_transpiler_cache.is_some());
+            debug_assert!(!self.macro_imports_are_plain);
 
             let bools: [bool; 17] = [
                 self.top_level_await,

test/bundler/transpiler/macro-test.test.ts

@@ -1,6 +1,6 @@
 import { escapeHTML } from "bun" with { type: "macro" };
 import { describe, expect, test } from "bun:test";
-import { bunEnv, bunExe, tempDir } from "harness";
+import { bunEnv, bunExe, isWindows, tempDir } from "harness";
 import { existsSync } from "node:fs";
 import path from "node:path";
 import defaultMacro, {
@@ -777,3 +777,80 @@ describe("macro VM env loader", () => {
     expect(withMacro).toEqual(withoutMacro);
   });
 });
+
+// `bun create <component>` bundles the component to learn what it reaches, and prints no code. It reads a macro
+// import as an ordinary import: the file of the macro is a file of the component, and the macro is not called.
+// Windows: `bun create <component>` does not reach its install step there.
+describe.concurrent.todoIf(isWindows)("bun create <component>", () => {
+  // The registry has no packages: `bun create` prints what it installs, and then its install step fails.
+  async function create(files: Record<string, string>, entry: string) {
+    using dir = tempDir("macro-create-component", files);
+    using registry = Bun.serve({ port: 0, fetch: () => new Response(null, { status: 404 }) });
+    await using proc = Bun.spawn({
+      cmd: [bunExe(), "create", entry],
+      cwd: String(dir),
+      env: {
+        ...bunEnv,
+        BUN_CONFIG_REGISTRY: registry.url.href,
+        // `bun create` exits without freeing the bundler. The ASAN lane would turn that into exit code 134.
+        ASAN_OPTIONS: [bunEnv.ASAN_OPTIONS, "detect_leaks=0"].filter(Boolean).join(":"),
+      },
+      stdout: "pipe",
+      stderr: "pipe",
+      stdin: "ignore",
+    });
+    const [stdout, stderr, exitCode] = await Promise.all([proc.stdout.text(), proc.stderr.text(), proc.exited]);
+    return {
+      install: stdout.split("\n").find(line => line.includes("--only-missing install")) ?? "",
+      created: stdout.split("\n").filter(line => line.startsWith(" create ")).length,
+      macroRan: existsSync(path.join(String(dir), "MACRO_RAN")),
+      stderr,
+      exitCode,
+    };
+  }
+
+  test.each([
+    ["an import attribute", `"./macro.ts" with { type: "macro" }`],
+    ["the macro: prefix", `"macro:./macro.ts"`],
+  ])("does not call a macro imported with %s, and installs what its file imports", async (_, specifier) => {
+    const { install, macroRan, stderr, exitCode } = await create(
+      {
+        "App.tsx": `import { one } from ${specifier};\nexport default function App() { return <div>{one()}</div>; }\n`,
+        "macro.ts": `import "bar";\nimport { writeFileSync } from "node:fs";\nimport { join } from "node:path";\nexport function one() {\n  writeFileSync(join(import.meta.dir, "MACRO_RAN"), "");\n  return 1;\n}\n`,
+        // Installed, so that a call of the macro could load its file.
+        "node_modules/bar/package.json": JSON.stringify({ name: "bar", version: "1.0.0" }),
+        "node_modules/bar/index.js": "",
+      },
+      "./App.tsx",
+    );
+    expect({ install, macroRan }, stderr).toEqual({
+      install: expect.stringContaining(" install -- bar "),
+      macroRan: false,
+    });
+    expect(exitCode).toBe(1);
+  });
+
+  test("picks the template from the class names in the file of a macro, as in any file of the component", async () => {
+    const { install, stderr } = await create(
+      {
+        "App.tsx": `import { one } from "./macro.tsx" with { type: "macro" };\nexport default function App() { return <div>{one()}</div>; }\n`,
+        "macro.tsx": `// <div className="flex items-center p-4 text-xl" />\nexport function one() {\n  return 1;\n}\n`,
+      },
+      "./App.tsx",
+    );
+    expect(install, stderr).toContain(" install -- bun-plugin-tailwind tailwindcss ");
+  });
+
+  test("fails for a macro import that is never called and names a missing export", async () => {
+    // As for an ordinary import. A TypeScript file drops an import that it never uses, so this is a .jsx file.
+    const { install, created, stderr, exitCode } = await create(
+      {
+        "App.jsx": `import { missing } from "./macro.js" with { type: "macro" };\nexport default function App() { return <div>hi</div>; }\n`,
+        "macro.js": `export function one() {\n  return 1;\n}\n`,
+      },
+      "./App.jsx",
+    );
+    expect(stderr).toContain(`No matching export in "macro.js" for import "missing"`);
+    expect({ install, created, exitCode }).toEqual({ install: "", created: 0, exitCode: 1 });
+  });
+});

test/cli/install/bun-add.test.ts

@@ -2,6 +2,7 @@ import type { BunLockFile } from "bun";
 import { $, file, spawn } from "bun";
 import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it, setDefaultTimeout, test } from "bun:test";
 import { randomBytes } from "crypto";
+import { existsSync } from "fs";
 import { access, appendFile, copyFile, mkdir, readlink, rm, writeFile } from "fs/promises";
 import {
   bunExe,
@@ -294,19 +295,23 @@ it("bun add --only-missing should not install existing package", async () => {
   }
 });
 
-// Writes `source` to entry-point.ts and returns what `bun <command> --analyze` adds to package.json. `urls` collects
+// Writes `source` to `entry` and returns what `bun <command> --analyze` adds to package.json. `urls` collects
 // its registry requests.
 async function analyze(
   command: "add" | "install",
   source: string,
-  { packageJson = { name: "foo" }, urls = [] }: { packageJson?: object; urls?: string[] } = {},
+  {
+    packageJson = { name: "foo" },
+    urls = [],
+    entry = "entry-point.ts",
+  }: { packageJson?: object; urls?: string[]; entry?: string } = {},
 ) {
   setHandler(dummyRegistry(urls));
   await writeFile(join(package_dir, "package.json"), JSON.stringify({ version: "0.0.1", ...packageJson }));
-  await writeFile(join(package_dir, "entry-point.ts"), source);
+  await writeFile(join(package_dir, entry), source);
   // The registry has no tarball for most of these names.
   await using proc = spawn({
-    cmd: [bunExe(), command, "--analyze", "--lockfile-only", "./entry-point.ts"],
+    cmd: [bunExe(), command, "--analyze", "--lockfile-only", `./${entry}`],
     cwd: package_dir,
     stdout: "pipe",
     stderr: "pipe",
@@ -405,6 +410,69 @@ it("bun add --analyze uses the nearest package.json with a name above the import
   expect(urls).toEqual([`${root_url}/bar`]);
 });
 
+// `--analyze` bundles the entry point to learn what it imports. It reads a macro import as an ordinary import: the
+// file of the macro is a file of the bundle, and the macro is not called.
+it.each(
+  (["add", "install"] as const).flatMap(command =>
+    [
+      ["an import attribute", `"./macro.ts" with { type: "macro" }`],
+      ["the macro: prefix", `"macro:./macro.ts"`],
+    ].map(([form, specifier]) => [command, form, specifier] as const),
+  ),
+)("bun %s --analyze adds what the file of a macro imported with %s imports", async (command, _, specifier) => {
+  // `bar` is not installed, so a call of the macro would fail to load its file.
+  await writeFile(join(package_dir, "macro.ts"), `import "bar";\nexport function one() {\n  return 1;\n}\n`);
+  const source = `import { one } from ${specifier};\nconsole.log(one());\n`;
+  expect(await analyze(command, source)).toEqual({ added: ["bar"], errors: [], exitCode: 0 });
+});
+
+it.each(["add", "install"] as const)(
+  "bun %s --analyze does not call a macro, and does not add a package that only its result names",
+  async command => {
+    await writeFile(
+      join(package_dir, "macro.ts"),
+      `import { writeFileSync } from "node:fs";\nimport { join } from "node:path";\nexport function name(n: string) {\n  writeFileSync(join(import.meta.dir, "MACRO_RAN"), "");\n  return n;\n}\n`,
+    );
+    const source = `import "baz";\nimport { name } from "./macro.ts" with { type: "macro" };\nawait import(name("bar"));\nrequire(name("qux"));\n`;
+    expect(await analyze(command, source)).toEqual({ added: ["baz"], errors: [], exitCode: 0 });
+    expect(existsSync(join(package_dir, "MACRO_RAN"))).toBe(false);
+  },
+);
+
+// The bundle is linked before `--analyze` reads it, so the file of a macro is checked as the file of an ordinary
+// import is. A TypeScript file drops an import that it never uses, so these are .js files.
+it.each([
+  [
+    "names an export that its file does not have",
+    `export function one() {\n  return 1;\n}\n`,
+    `No matching export in "macro.js" for import "missing"`,
+  ],
+  ["names a file that does not parse", `export function missing( {\n  return 1;\n}\n`, `Expected "}" but found "1"`],
+])("bun add --analyze fails for a macro import that is never called and %s", async (_, macro, error) => {
+  await writeFile(join(package_dir, "macro.js"), macro);
+  const source = `import { missing } from "./macro.js" with { type: "macro" };\nimport "baz";\n`;
+  expect(await analyze("add", source, { entry: "entry-point.js" })).toEqual({
+    added: [],
+    errors: expect.arrayContaining([expect.stringContaining(error)]),
+    exitCode: 1,
+  });
+});
+
+it("bun add --analyze fails for a require() that reaches a macro whose file has a top-level await", async () => {
+  // The program runs: for the runtime the file of the macro is not a dependency of the module that calls the macro.
+  await writeFile(join(package_dir, "macro.ts"), `await 0;\nexport function one() {\n  return 1;\n}\n`);
+  await writeFile(
+    join(package_dir, "calls.ts"),
+    `import { one } from "./macro.ts" with { type: "macro" };\nexport const value = one();\n`,
+  );
+  const source = `import "baz";\nconsole.log(require("./calls.ts").value);\n`;
+  expect(await analyze("add", source)).toEqual({
+    added: [],
+    errors: [expect.stringContaining(`the transitive dependency "macro.ts" contains a top-level await`)],
+    exitCode: 1,
+  });
+});
+
 it("bun add --analyze should scan dependencies", async () => {
   const urls: string[] = [];
   setHandler(dummyRegistry(urls));