WIP

tgross35 · tgross35 · commit 00390e8b77c3 · 2025-01-29T04:13:51.000Z
diff --git a/compiler/rustc_builtin_macros/src/standard_library_imports.rs b/compiler/rustc_builtin_macros/src/standard_library_imports.rs
@@ -46,7 +46,7 @@ pub fn inject(
     // .rev() to preserve ordering above in combination with insert(0, ...)
     for &name in names.iter().rev() {
         let ident_span = if edition >= Edition2018 { span } else { call_site };
-        let item = if name == sym::compiler_builtins {
+        let item = /* if name == sym::compiler_builtins {
             // compiler_builtins is a private implementation detail. We only
             // need to insert it into the crate graph for linking and should not
             // expose any of its public API.
@@ -61,7 +61,7 @@ pub fn inject(
                 thin_vec![],
                 ast::ItemKind::ExternCrate(Some(name)),
             )
-        } else {
+        } else */{
             cx.item(
                 span,
                 Ident::new(name, ident_span),
diff --git a/compiler/rustc_metadata/src/creader.rs b/compiler/rustc_metadata/src/creader.rs
@@ -24,7 +24,9 @@ use rustc_index::IndexVec;
 use rustc_middle::bug;
 use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
 use rustc_session::config::{self, CrateType, ExternLocation};
-use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
+use rustc_session::cstore::{
+    CrateDepKind, CrateSource, CrateStore, ExternCrate, ExternCrateSource,
+};
 use rustc_session::lint::{self, BuiltinLintDiag};
 use rustc_session::output::validate_crate_name;
 use rustc_session::search_paths::PathKind;
@@ -157,6 +159,44 @@ impl<'a> std::fmt::Debug for CrateDump<'a> {
     }
 }
 
+///
+#[derive(Clone, Copy)]
+enum CrateOrigin<'a> {
+    /// This crate was a dependency of another crate.
+    Dependency {
+        dep_root: &'a CratePaths,
+        /// Dependency info about this crate.
+        dep: &'a CrateDep,
+    },
+    ///
+    Injected,
+    /// An extern that has been provided with the `force` option.
+    ForcedExtern,
+    ///
+    ExternPrelude,
+    /// Provided by `extern crate foo` or `extern crate foo as bar`.
+    #[allow(unused)]
+    AstExtern { name: Symbol, orig_name: Option<Symbol> },
+}
+
+impl<'a> CrateOrigin<'a> {
+    /// Return the dependency root, if any.
+    fn dep_root(&self) -> Option<&'a CratePaths> {
+        match self {
+            CrateOrigin::Dependency { dep_root, .. } => Some(dep_root),
+            _ => None,
+        }
+    }
+
+    /// Return dependency information, if any.
+    fn dep(&self) -> Option<&'a CrateDep> {
+        match self {
+            CrateOrigin::Dependency { dep, .. } => Some(dep),
+            _ => None,
+        }
+    }
+}
+
 impl CStore {
     pub fn from_tcx(tcx: TyCtxt<'_>) -> FreezeReadGuard<'_, CStore> {
         FreezeReadGuard::map(tcx.untracked().cstore.read(), |cstore| {
@@ -404,7 +444,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         &self,
         name: Symbol,
         private_dep: Option<bool>,
-        dep_root: Option<&CratePaths>,
+        origin: CrateOrigin<'_>,
     ) -> bool {
         // Standard library crates are never private.
         if STDLIB_STABLE_CRATES.contains(&name) {
@@ -414,16 +454,23 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
 
         let extern_private = self.sess.opts.externs.get(name.as_str()).map(|e| e.is_private_dep);
 
-        if name == sym::compiler_builtins {
-            // compiler_builtins is a private implementation detail and should never show up in
-            // diagnostics. See also the note referencing #113634 in
-            // `rustc_builtin_macros::...::inject`.
+        if matches!(origin, CrateOrigin::Injected) {
             return true;
         }
+
+        // if name == sym::compiler_builtins {
+        //     // compiler_builtins is an implementation detail and should never show up in
+        //     // diagnostics. `dep_root` is `None` if the requested crate came from an `extern
+        //     // crate ..`, which is the case since `compiler_builtins` is injected into AST at
+        //     // `rustc_builtin_macros::standard_library_imports::inject`.
+        //     //
+        //     // See also the note at that module referencing #113634.
+        //     return true;
+        // }
         // Any descendants of `std` should be private. These crates are usually not marked
         // private in metadata, so we ignore that field.
         if extern_private.is_none()
-            && let Some(dep) = dep_root
+            && let Some(dep) = origin.dep_root()
             && STDLIB_STABLE_CRATES.contains(&dep.name)
         {
             return true;
@@ -441,7 +488,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     fn register_crate(
         &mut self,
         host_lib: Option<Library>,
-        dep_root: Option<&CratePaths>,
+        origin: CrateOrigin<'_>,
         lib: Library,
         dep_kind: CrateDepKind,
         name: Symbol,
@@ -453,7 +500,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         let Library { source, metadata } = lib;
         let crate_root = metadata.get_root();
         let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
-        let private_dep = self.is_private_dep(name, private_dep, dep_root);
+        let private_dep = self.is_private_dep(name, private_dep, origin);
 
         // Claim this crate number and cache it
         let feed = self.cstore.intern_stable_crate_id(&crate_root, self.tcx)?;
@@ -469,7 +516,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // Maintain a reference to the top most crate.
         // Stash paths for top-most crate locally if necessary.
         let crate_paths;
-        let dep_root = if let Some(dep_root) = dep_root {
+        let dep_root = if let Some(dep_root) = origin.dep_root() {
             dep_root
         } else {
             crate_paths = CratePaths::new(crate_root.name(), source.clone());
@@ -577,17 +624,23 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         name: Symbol,
         span: Span,
         dep_kind: CrateDepKind,
+        origin: CrateOrigin<'_>,
     ) -> Option<CrateNum> {
         self.used_extern_options.insert(name);
-        match self.maybe_resolve_crate(name, dep_kind, None) {
+        match self.maybe_resolve_crate(name, dep_kind, origin) {
             Ok(cnum) => {
                 self.cstore.set_used_recursively(cnum);
                 Some(cnum)
             }
             Err(err) => {
                 debug!("failed to resolve crate {} {:?}", name, dep_kind);
-                let missing_core =
-                    self.maybe_resolve_crate(sym::core, CrateDepKind::Explicit, None).is_err();
+                let missing_core = self
+                    .maybe_resolve_crate(
+                        sym::core,
+                        CrateDepKind::Explicit,
+                        CrateOrigin::ExternPrelude,
+                    )
+                    .is_err();
                 err.report(self.sess, span, missing_core);
                 None
             }
@@ -598,15 +651,15 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         &'b mut self,
         name: Symbol,
         mut dep_kind: CrateDepKind,
-        dep_of: Option<(&'b CratePaths, &'b CrateDep)>,
+        origin: CrateOrigin<'b>,
     ) -> Result<CrateNum, CrateError> {
         info!("resolving crate `{}`", name);
         if !name.as_str().is_ascii() {
             return Err(CrateError::NonAsciiName(name));
         }
 
-        let dep_root = dep_of.map(|d| d.0);
-        let dep = dep_of.map(|d| d.1);
+        let dep_root = origin.dep_root();
+        let dep = origin.dep();
         let hash = dep.map(|d| d.hash);
         let host_hash = dep.map(|d| d.host_hash).flatten();
         let extra_filename = dep.map(|d| &d.extra_filename[..]);
@@ -649,7 +702,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 // not specified by `--extern` on command line parameters, it may be
                 // `private-dependency` when `register_crate` is called for the first time. Then it must be updated to
                 // `public-dependency` here.
-                let private_dep = self.is_private_dep(name, private_dep, dep_root);
+                let private_dep = self.is_private_dep(name, private_dep, origin);
                 let data = self.cstore.get_crate_data_mut(cnum);
                 if data.is_proc_macro_crate() {
                     dep_kind = CrateDepKind::MacrosOnly;
@@ -660,7 +713,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             }
             (LoadResult::Loaded(library), host_library) => {
                 info!("register newly loaded library for `{}`", name);
-                self.register_crate(host_library, dep_root, library, dep_kind, name, private_dep)
+                self.register_crate(host_library, origin, library, dep_kind, name, private_dep)
             }
             _ => panic!(),
         }
@@ -736,7 +789,10 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                 CrateDepKind::MacrosOnly => CrateDepKind::MacrosOnly,
                 _ => dep.kind,
             };
-            let cnum = self.maybe_resolve_crate(dep.name, dep_kind, Some((dep_root, &dep)))?;
+            let cnum = self.maybe_resolve_crate(dep.name, dep_kind, CrateOrigin::Dependency {
+                dep_root,
+                dep: &dep,
+            })?;
             crate_num_map.push(cnum);
         }
 
@@ -830,7 +886,9 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         };
         info!("panic runtime not found -- loading {}", name);
 
-        let Some(cnum) = self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit) else {
+        let Some(cnum) =
+            self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
+        else {
             return;
         };
         let data = self.cstore.get_crate_data(cnum);
@@ -859,7 +917,9 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         info!("loading profiler");
 
         let name = Symbol::intern(&self.sess.opts.unstable_opts.profiler_runtime);
-        let Some(cnum) = self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit) else {
+        let Some(cnum) =
+            self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
+        else {
             return;
         };
         let data = self.cstore.get_crate_data(cnum);
@@ -972,12 +1032,71 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             if entry.force {
                 let name_interned = Symbol::intern(name);
                 if !self.used_extern_options.contains(&name_interned) {
-                    self.resolve_crate(name_interned, DUMMY_SP, CrateDepKind::Explicit);
+                    self.resolve_crate(
+                        name_interned,
+                        DUMMY_SP,
+                        CrateDepKind::Explicit,
+                        CrateOrigin::ForcedExtern,
+                    );
                 }
             }
         }
     }
 
+    fn inject_compiler_builtins(&mut self, krate: &ast::Crate) {
+        if attr::contains_name(&krate.attrs, sym::compiler_builtins)
+            || attr::contains_name(&krate.attrs, sym::no_core)
+        {
+            // `compiler_builtins` does not get extern builtins, nor do `#![no_core]` crates
+            info!("`compiler_builtins` unneeded");
+            return;
+        }
+
+        // let Some((cnum, _meta)) = self
+        //     .cstore
+        //     .iter_crate_data()
+        //     .find(|(_cnum, meta)| meta.name() == sym::compiler_builtins)
+        // else {
+        //     info!("`compiler_builtins` crate was not found for");
+        //     return;
+        // };
+        //
+        info!("looking for builtins in {}", self.cstore.crate_name(LOCAL_CRATE));
+
+        // self.process_extern_crate(
+        //     ast::ItemKind::ExternCrate(Some(sym::compiler_builtins)),
+        //     def_id,
+        //     definitions,
+        // )
+
+        let res = self.maybe_resolve_crate(
+            sym::compiler_builtins,
+            CrateDepKind::Explicit,
+            CrateOrigin::Injected,
+        );
+
+        info!("BUILTINS RESULT: {res:?}");
+
+        // let cnum = self
+        //     .resolve_crate(
+        //         sym::compiler_builtins,
+        //         DUMMY_SP,
+        //         CrateDepKind::Explicit,
+        //         CrateOrigin::Injected,
+        //     )
+        //     .expect("unresolved builtins");
+
+        // self.cstore.update_extern_crate(cnum, ExternCrate {
+        //     src: ExternCrateSource::Path,
+        //     // src: ExternCrateSource::Extern(def_id.to_def_id()),
+        //     span: DUMMY_SP,
+        //     path_len: "compiler_builtins".len(),
+        //     dependency_of: LOCAL_CRATE,
+        // });
+
+        // self.cstore.get_crate_data_mut(LOCAL_CRATE).add_dependency(cnum);
+    }
+
     fn inject_dependency_if(
         &mut self,
         krate: CrateNum,
@@ -1087,6 +1206,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     }
 
     pub fn postprocess(&mut self, krate: &ast::Crate) {
+        self.inject_compiler_builtins(krate);
         self.inject_forced_externs();
         self.inject_profiler_runtime();
         self.inject_allocator_crate(krate);
@@ -1098,6 +1218,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         info!("{:?}", CrateDump(self.cstore));
     }
 
+    /// Process an `extern crate foo` AST node.
     pub fn process_extern_crate(
         &mut self,
         item: &ast::Item,
@@ -1123,7 +1244,11 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
                     CrateDepKind::Explicit
                 };
 
-                let cnum = self.resolve_crate(name, item.span, dep_kind)?;
+                let cnum =
+                    self.resolve_crate(name, item.span, dep_kind, CrateOrigin::AstExtern {
+                        name,
+                        orig_name,
+                    })?;
 
                 let path_len = definitions.def_path(def_id).data.len();
                 self.cstore.update_extern_crate(cnum, ExternCrate {
@@ -1139,7 +1264,8 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     }
 
     pub fn process_path_extern(&mut self, name: Symbol, span: Span) -> Option<CrateNum> {
-        let cnum = self.resolve_crate(name, span, CrateDepKind::Explicit)?;
+        let cnum =
+            self.resolve_crate(name, span, CrateDepKind::Explicit, CrateOrigin::ExternPrelude)?;
 
         self.cstore.update_extern_crate(cnum, ExternCrate {
             src: ExternCrateSource::Path,
@@ -1153,7 +1279,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
     }
 
     pub fn maybe_process_path_extern(&mut self, name: Symbol) -> Option<CrateNum> {
-        self.maybe_resolve_crate(name, CrateDepKind::Explicit, None).ok()
+        self.maybe_resolve_crate(name, CrateDepKind::Explicit, CrateOrigin::ExternPrelude).ok()
     }
 }
 
diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs
