Remove dead code from bun_options_types and bun_http_types

src/ast/import_record.rs

@@ -2,8 +2,6 @@
 //!
 //! Lives in `bun_ast` so `Ast` (which holds `Vec<ImportRecord>`) is
 //! self-contained and `bun_js_printer` can drop its `bun_js_parser` dep.
-//! `ImportKind::to_api()` lives in `bun_ast::ImportKindExt` (would
-//! back-edge into the schema crate).
 
 use crate::Range;
 use bun_paths::fs::Path;

src/ast/lib.rs

@@ -131,9 +131,6 @@ impl ImportKind {
             || self == Self::Url
             || self == Self::Composes
     }
-
-    // `to_api()` lives in `bun_ast::ImportKindExt` — depends on
-    // `schema::api::ImportKind` which sits in a higher-tier crate.
 }
 
 // ───────────────────────────────────────────────────────────────────────────

src/ast/loader.rs

@@ -1,9 +1,9 @@
 //! `Loader` + `SideEffects`.
 //!
-//! Data-only enum + pure predicates. `to_api()` / `from_api()` / `API_NAMES` /
-//! `LoaderOptional::from_api` live in `bun_options_types::LoaderExt` (would
-//! back-edge into the schema crate). `to_mime_type` / `from_mime_type` live in
-//! `bun_http_types` (would back-edge into `bun_http::MimeType`).
+//! Data-only enum + pure predicates. `to_api()` / `from_api()` / `API_NAMES`
+//! live in `bun_options_types::LoaderExt` (would back-edge into the schema
+//! crate). `to_mime_type` / `from_mime_type` live in `bun_http_types` (would
+//! back-edge into `bun_http::MimeType`).
 
 use enum_map::Enum;
 

src/http_types/Method.rs

@@ -230,23 +230,6 @@ pub enum Optional {
 }
 
 impl Optional {
-    pub fn contains(&self, other: &Optional) -> bool {
-        if matches!(self, Optional::Any) {
-            return true;
-        }
-        if matches!(other, Optional::Any) {
-            return true;
-        }
-
-        let Optional::Method(this_set) = self else {
-            unreachable!()
-        };
-        let Optional::Method(other_set) = other else {
-            unreachable!()
-        };
-        this_set.intersection(*other_set).len() > 0
-    }
-
     pub fn insert(&mut self, method: Method) {
         match self {
             Optional::Any => {}

src/http_types/mime_type_list_enum.rs

@@ -34,8 +34,6 @@ impl MimeTypeList {
         self.0.len()
     }
 
-    pub const COUNT: usize = 2310;
-
     pub const ALL: &'static [MimeTypeList] = ALL;
 }
 

src/options_types/bundle_enums.rs

@@ -7,7 +7,7 @@
 //! `from_api`, `API_NAMES`) remain here as sealed extension traits.
 
 use crate::schema::api;
-use bun_ast::{Loader, LoaderOptional, Target};
+use bun_ast::{Loader, Target};
 
 #[repr(u8)]
 #[derive(Copy, Clone, Eq, PartialEq, Debug)]
@@ -128,8 +128,6 @@ mod sealed {
     pub trait Sealed {}
     impl Sealed for bun_ast::Target {}
     impl Sealed for bun_ast::Loader {}
-    impl Sealed for bun_ast::LoaderOptional {}
-    impl Sealed for bun_ast::ImportKind {}
 }
 
 /// `schema::api`-coupled methods on [`bun_ast::Target`]. Import alongside
@@ -252,44 +250,6 @@ impl LoaderExt for Loader {
     }
 }
 
-/// `schema::api`-coupled methods on [`bun_ast::LoaderOptional`].
-pub trait LoaderOptionalExt: sealed::Sealed {
-    fn from_api(loader: api::Loader) -> LoaderOptional;
-}
-
-impl LoaderOptionalExt for LoaderOptional {
-    fn from_api(loader: api::Loader) -> LoaderOptional {
-        if loader == api::Loader::_none {
-            LoaderOptional::NONE
-        } else {
-            LoaderOptional::from_loader(Loader::from_api(loader))
-        }
-    }
-}
-
-// ─── ImportKind: schema-coupled extension methods ─────────────────────────
-
-/// `schema::api`-coupled methods on [`bun_ast::ImportKind`].
-pub trait ImportKindExt: sealed::Sealed {
-    fn to_api(self) -> api::ImportKind;
-}
-
-impl ImportKindExt for bun_ast::ImportKind {
-    fn to_api(self) -> api::ImportKind {
-        use bun_ast::ImportKind;
-        match self {
-            ImportKind::EntryPointRun | ImportKind::EntryPointBuild => api::ImportKind::entry_point,
-            ImportKind::Stmt => api::ImportKind::stmt,
-            ImportKind::Require => api::ImportKind::require,
-            ImportKind::Dynamic => api::ImportKind::dynamic,
-            ImportKind::RequireResolve => api::ImportKind::require_resolve,
-            ImportKind::At => api::ImportKind::at,
-            ImportKind::Url => api::ImportKind::url,
-            _ => api::ImportKind::internal,
-        }
-    }
-}
-
 // ─── move-in: TYPE_ONLY from bun_runtime::bake::framework ──────────────────────────
 
 /// Virtual module backing for a

src/options_types/jsx.rs

@@ -232,29 +232,6 @@ impl Pragma {
         }
     }
 
-    pub fn parse_package_name(str: &[u8]) -> &[u8] {
-        if str.is_empty() {
-            return str;
-        }
-        if str[0] == b'@' {
-            if let Some(first_slash) = strings::index_of_char(&str[1..], b'/') {
-                let first_slash = first_slash as usize;
-                let remainder = &str[1 + first_slash + 1..];
-
-                if let Some(last_slash) = strings::index_of_char(remainder, b'/') {
-                    let last_slash = last_slash as usize;
-                    return &str[0..first_slash + 1 + last_slash + 1];
-                }
-            }
-        }
-
-        if let Some(first_slash) = strings::index_of_char(str, b'/') {
-            return &str[0..first_slash as usize];
-        }
-
-        str
-    }
-
     /// When `package_name` is the default `"react"`, this borrows the
     /// interned `defaults::IMPORT_SOURCE*` with zero allocations.
     pub fn set_import_source(&mut self) {

src/options_types/lib.rs

@@ -22,8 +22,8 @@ pub use jsx as JSX;
 // Only the `schema::api`-coupled extension traits and option-only types
 // (`Format`, `ModuleType`, …) are surfaced from this crate.
 pub use bundle_enums::{
-    BuiltInModule, BundlePackage, ForceNodeEnv, Format, ImportKindExt, LOADER_API_NAMES, LoaderExt,
-    LoaderOptionalExt, ModuleType, TargetExt, WindowsOptions,
+    BuiltInModule, BundlePackage, ForceNodeEnv, Format, LOADER_API_NAMES, LoaderExt, ModuleType,
+    TargetExt, WindowsOptions,
 };
 
 /// Compiled-standalone-binary virtual filesystem path prefix + predicate.
@@ -46,10 +46,6 @@ pub mod standalone_path {
     #[cfg(windows)]
     pub const BASE_PUBLIC_PATH: &str = "B:/~BUN/";
 
-    #[cfg(windows)]
-    pub const BASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX: &str =
-        const_format::concatcp!(BASE_PUBLIC_PATH, "root/");
-
     #[inline]
     pub(crate) fn is_bun_standalone_file_path_canonicalized(str_: &[u8]) -> bool {
         str_.starts_with(BASE_PATH.as_bytes())

src/options_types/schema.rs

@@ -430,22 +430,6 @@ pub mod api {
         }
     }
 
-    /// Open `enum(u8)` in the wire schema. Kept closed.
-    #[repr(u8)]
-    #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
-    pub enum ImportKind {
-        #[default]
-        _none = 0,
-        entry_point = 1,
-        stmt = 2,
-        require = 3,
-        dynamic = 4,
-        require_resolve = 5,
-        at = 6,
-        url = 7,
-        internal = 8,
-    }
-
     // ─── peechy batch 2: hand-expanded for downstream wfs ────────────────
     // Jsx / JsxRuntime / StringMap / EnvConfig / LoadedEnvConfig /
     // LoadedRouteConfig / RouteConfig / FrameworkEntryPoint{,Type,Map,Message} /

test/internal/source-lints/removed-dead-symbols.test.ts

@@ -0,0 +1,80 @@
+// Guards against reintroduction of previously-removed dead `pub` items.
+//
+// The workspace compiles with `dead_code = "deny"` and `unreachable_pub =
+// "deny"`, so rustc already catches unreachable private items. What slips
+// through are `pub` items re-exported at a crate root: they're reachable, so
+// the lint is satisfied, but nothing in any other crate ever calls them. Each
+// entry below was verified to have zero references anywhere in `src/`,
+// `build/debug/codegen/`, or `src/codegen/` (beyond its own definition and
+// re-export) before being deleted. Pinning the absence here stops a merge-era
+// revert or copy-paste from quietly bringing one back.
+//
+// To add an entry after removing a dead symbol: append `{ file, pattern }`
+// where `pattern` matches the definition line and nothing else in that file.
+
+import { file } from "bun";
+import { expect, test } from "bun:test";
+import path from "node:path";
+
+const root = path.resolve(import.meta.dir, "..", "..", "..");
+
+const removed: { file: string; pattern: RegExp; name: string }[] = [
+  {
+    file: "src/options_types/jsx.rs",
+    pattern: /\bpub fn parse_package_name\b/,
+    name: "jsx::Pragma::parse_package_name",
+  },
+  {
+    file: "src/options_types/bundle_enums.rs",
+    pattern: /\bpub trait LoaderOptionalExt\b/,
+    name: "bundle_enums::LoaderOptionalExt",
+  },
+  {
+    file: "src/options_types/bundle_enums.rs",
+    pattern: /\bpub trait ImportKindExt\b/,
+    name: "bundle_enums::ImportKindExt",
+  },
+  {
+    file: "src/options_types/schema.rs",
+    pattern: /\bpub enum ImportKind\b/,
+    name: "schema::api::ImportKind",
+  },
+  {
+    file: "src/options_types/lib.rs",
+    pattern: /\bBASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX\b/,
+    name: "standalone_path::BASE_PUBLIC_PATH_WITH_DEFAULT_SUFFIX (duplicate of bun_standalone_graph's)",
+  },
+  {
+    file: "src/http_types/mime_type_list_enum.rs",
+    pattern: /\bpub const COUNT\b/,
+    name: "MimeTypeList::COUNT",
+  },
+  {
+    file: "src/http_types/Method.rs",
+    pattern: /\bpub fn contains\(&self, other: &Optional\)/,
+    name: "Method::Optional::contains",
+  },
+];
+
+for (const { file: rel, pattern, name } of removed) {
+  test(`${name} stays removed from ${rel}`, async () => {
+    const abs = path.join(root, rel);
+    const content = await file(abs).text();
+    const lines = content.split("\n");
+    const hits: string[] = [];
+    for (let i = 0; i < lines.length; i++) {
+      if (pattern.test(lines[i])) hits.push(`${rel}:${i + 1}: ${lines[i].trim()}`);
+    }
+    if (hits.length > 0) {
+      throw new Error(
+        `${name} was previously removed as dead code (zero workspace references) ` +
+          `but is present again in ${rel}:\n` +
+          hits.map(h => `  ${h}`).join("\n") +
+          `\nIf this symbol now has a real caller, delete its entry from ` +
+          `test/internal/source-lints/removed-dead-symbols.test.ts. Otherwise, ` +
+          `remove the dead definition.`,
+      );
+    }
+    expect(hits).toEqual([]);
+  });
+}