Skip to content

Commit 00390e8

Browse files
tgross35tgross35
committed
WIP
1 parent d5f9b73 commit 00390e8

File tree

3 files changed

+159
-31
lines changed

3 files changed

+159
-31
lines changed

‎compiler/rustc_builtin_macros/src/standard_library_imports.rs‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -46,7 +46,7 @@ pub fn inject(
4646
// .rev() to preserve ordering above in combination with insert(0, ...)
4747
for &name in names.iter().rev() {
4848
let ident_span = if edition >= Edition2018 { span } else { call_site };
49-
let item = if name == sym::compiler_builtins {
49+
let item = /* if name == sym::compiler_builtins {
5050
// compiler_builtins is a private implementation detail. We only
5151
// need to insert it into the crate graph for linking and should not
5252
// expose any of its public API.
@@ -61,7 +61,7 @@ pub fn inject(
6161
thin_vec![],
6262
ast::ItemKind::ExternCrate(Some(name)),
6363
)
64-
} else {
64+
} else */{
6565
cx.item(
6666
span,
6767
Ident::new(name, ident_span),

‎compiler/rustc_metadata/src/creader.rs‎

Lines changed: 151 additions & 25 deletions
Original file line numberDiff line numberDiff line change
@@ -24,7 +24,9 @@ use rustc_index::IndexVec;
2424
use rustc_middle::bug;
2525
use rustc_middle::ty::{TyCtxt, TyCtxtFeed};
2626
use rustc_session::config::{self, CrateType, ExternLocation};
27-
use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate, ExternCrateSource};
27+
use rustc_session::cstore::{
28+
CrateDepKind, CrateSource, CrateStore, ExternCrate, ExternCrateSource,
29+
};
2830
use rustc_session::lint::{self, BuiltinLintDiag};
2931
use rustc_session::output::validate_crate_name;
3032
use rustc_session::search_paths::PathKind;
@@ -157,6 +159,44 @@ impl<'a> std::fmt::Debug for CrateDump<'a> {
157159
}
158160
}
159161

162+
///
163+
#[derive(Clone, Copy)]
164+
enum CrateOrigin<'a> {
165+
/// This crate was a dependency of another crate.
166+
Dependency {
167+
dep_root: &'a CratePaths,
168+
/// Dependency info about this crate.
169+
dep: &'a CrateDep,
170+
},
171+
///
172+
Injected,
173+
/// An extern that has been provided with the `force` option.
174+
ForcedExtern,
175+
///
176+
ExternPrelude,
177+
/// Provided by `extern crate foo` or `extern crate foo as bar`.
178+
#[allow(unused)]
179+
AstExtern { name: Symbol, orig_name: Option<Symbol> },
180+
}
181+
182+
impl<'a> CrateOrigin<'a> {
183+
/// Return the dependency root, if any.
184+
fn dep_root(&self) -> Option<&'a CratePaths> {
185+
match self {
186+
CrateOrigin::Dependency { dep_root, .. } => Some(dep_root),
187+
_ => None,
188+
}
189+
}
190+
191+
/// Return dependency information, if any.
192+
fn dep(&self) -> Option<&'a CrateDep> {
193+
match self {
194+
CrateOrigin::Dependency { dep, .. } => Some(dep),
195+
_ => None,
196+
}
197+
}
198+
}
199+
160200
impl CStore {
161201
pub fn from_tcx(tcx: TyCtxt<'_>) -> FreezeReadGuard<'_, CStore> {
162202
FreezeReadGuard::map(tcx.untracked().cstore.read(), |cstore| {
@@ -404,7 +444,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
404444
&self,
405445
name: Symbol,
406446
private_dep: Option<bool>,
407-
dep_root: Option<&CratePaths>,
447+
origin: CrateOrigin<'_>,
408448
) -> bool {
409449
// Standard library crates are never private.
410450
if STDLIB_STABLE_CRATES.contains(&name) {
@@ -414,16 +454,23 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
414454

415455
let extern_private = self.sess.opts.externs.get(name.as_str()).map(|e| e.is_private_dep);
416456

417-
if name == sym::compiler_builtins {
418-
// compiler_builtins is a private implementation detail and should never show up in
419-
// diagnostics. See also the note referencing #113634 in
420-
// `rustc_builtin_macros::...::inject`.
457+
if matches!(origin, CrateOrigin::Injected) {
421458
return true;
422459
}
460+
461+
// if name == sym::compiler_builtins {
462+
// // compiler_builtins is an implementation detail and should never show up in
463+
// // diagnostics. `dep_root` is `None` if the requested crate came from an `extern
464+
// // crate ..`, which is the case since `compiler_builtins` is injected into AST at
465+
// // `rustc_builtin_macros::standard_library_imports::inject`.
466+
// //
467+
// // See also the note at that module referencing #113634.
468+
// return true;
469+
// }
423470
// Any descendants of `std` should be private. These crates are usually not marked
424471
// private in metadata, so we ignore that field.
425472
if extern_private.is_none()
426-
&& let Some(dep) = dep_root
473+
&& let Some(dep) = origin.dep_root()
427474
&& STDLIB_STABLE_CRATES.contains(&dep.name)
428475
{
429476
return true;
@@ -441,7 +488,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
441488
fn register_crate(
442489
&mut self,
443490
host_lib: Option<Library>,
444-
dep_root: Option<&CratePaths>,
491+
origin: CrateOrigin<'_>,
445492
lib: Library,
446493
dep_kind: CrateDepKind,
447494
name: Symbol,
@@ -453,7 +500,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
453500
let Library { source, metadata } = lib;
454501
let crate_root = metadata.get_root();
455502
let host_hash = host_lib.as_ref().map(|lib| lib.metadata.get_root().hash());
456-
let private_dep = self.is_private_dep(name, private_dep, dep_root);
503+
let private_dep = self.is_private_dep(name, private_dep, origin);
457504

458505
// Claim this crate number and cache it
459506
let feed = self.cstore.intern_stable_crate_id(&crate_root, self.tcx)?;
@@ -469,7 +516,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
469516
// Maintain a reference to the top most crate.
470517
// Stash paths for top-most crate locally if necessary.
471518
let crate_paths;
472-
let dep_root = if let Some(dep_root) = dep_root {
519+
let dep_root = if let Some(dep_root) = origin.dep_root() {
473520
dep_root
474521
} else {
475522
crate_paths = CratePaths::new(crate_root.name(), source.clone());
@@ -577,17 +624,23 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
577624
name: Symbol,
578625
span: Span,
579626
dep_kind: CrateDepKind,
627+
origin: CrateOrigin<'_>,
580628
) -> Option<CrateNum> {
581629
self.used_extern_options.insert(name);
582-
match self.maybe_resolve_crate(name, dep_kind, None) {
630+
match self.maybe_resolve_crate(name, dep_kind, origin) {
583631
Ok(cnum) => {
584632
self.cstore.set_used_recursively(cnum);
585633
Some(cnum)
586634
}
587635
Err(err) => {
588636
debug!("failed to resolve crate {} {:?}", name, dep_kind);
589-
let missing_core =
590-
self.maybe_resolve_crate(sym::core, CrateDepKind::Explicit, None).is_err();
637+
let missing_core = self
638+
.maybe_resolve_crate(
639+
sym::core,
640+
CrateDepKind::Explicit,
641+
CrateOrigin::ExternPrelude,
642+
)
643+
.is_err();
591644
err.report(self.sess, span, missing_core);
592645
None
593646
}
@@ -598,15 +651,15 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
598651
&'b mut self,
599652
name: Symbol,
600653
mut dep_kind: CrateDepKind,
601-
dep_of: Option<(&'b CratePaths, &'b CrateDep)>,
654+
origin: CrateOrigin<'b>,
602655
) -> Result<CrateNum, CrateError> {
603656
info!("resolving crate `{}`", name);
604657
if !name.as_str().is_ascii() {
605658
return Err(CrateError::NonAsciiName(name));
606659
}
607660

608-
let dep_root = dep_of.map(|d| d.0);
609-
let dep = dep_of.map(|d| d.1);
661+
let dep_root = origin.dep_root();
662+
let dep = origin.dep();
610663
let hash = dep.map(|d| d.hash);
611664
let host_hash = dep.map(|d| d.host_hash).flatten();
612665
let extra_filename = dep.map(|d| &d.extra_filename[..]);
@@ -649,7 +702,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
649702
// not specified by `--extern` on command line parameters, it may be
650703
// `private-dependency` when `register_crate` is called for the first time. Then it must be updated to
651704
// `public-dependency` here.
652-
let private_dep = self.is_private_dep(name, private_dep, dep_root);
705+
let private_dep = self.is_private_dep(name, private_dep, origin);
653706
let data = self.cstore.get_crate_data_mut(cnum);
654707
if data.is_proc_macro_crate() {
655708
dep_kind = CrateDepKind::MacrosOnly;
@@ -660,7 +713,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
660713
}
661714
(LoadResult::Loaded(library), host_library) => {
662715
info!("register newly loaded library for `{}`", name);
663-
self.register_crate(host_library, dep_root, library, dep_kind, name, private_dep)
716+
self.register_crate(host_library, origin, library, dep_kind, name, private_dep)
664717
}
665718
_ => panic!(),
666719
}
@@ -736,7 +789,10 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
736789
CrateDepKind::MacrosOnly => CrateDepKind::MacrosOnly,
737790
_ => dep.kind,
738791
};
739-
let cnum = self.maybe_resolve_crate(dep.name, dep_kind, Some((dep_root, &dep)))?;
792+
let cnum = self.maybe_resolve_crate(dep.name, dep_kind, CrateOrigin::Dependency {
793+
dep_root,
794+
dep: &dep,
795+
})?;
740796
crate_num_map.push(cnum);
741797
}
742798

@@ -830,7 +886,9 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
830886
};
831887
info!("panic runtime not found -- loading {}", name);
832888

833-
let Some(cnum) = self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit) else {
889+
let Some(cnum) =
890+
self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
891+
else {
834892
return;
835893
};
836894
let data = self.cstore.get_crate_data(cnum);
@@ -859,7 +917,9 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
859917
info!("loading profiler");
860918

861919
let name = Symbol::intern(&self.sess.opts.unstable_opts.profiler_runtime);
862-
let Some(cnum) = self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit) else {
920+
let Some(cnum) =
921+
self.resolve_crate(name, DUMMY_SP, CrateDepKind::Implicit, CrateOrigin::Injected)
922+
else {
863923
return;
864924
};
865925
let data = self.cstore.get_crate_data(cnum);
@@ -972,12 +1032,71 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
9721032
if entry.force {
9731033
let name_interned = Symbol::intern(name);
9741034
if !self.used_extern_options.contains(&name_interned) {
975-
self.resolve_crate(name_interned, DUMMY_SP, CrateDepKind::Explicit);
1035+
self.resolve_crate(
1036+
name_interned,
1037+
DUMMY_SP,
1038+
CrateDepKind::Explicit,
1039+
CrateOrigin::ForcedExtern,
1040+
);
9761041
}
9771042
}
9781043
}
9791044
}
9801045

1046+
fn inject_compiler_builtins(&mut self, krate: &ast::Crate) {
1047+
if attr::contains_name(&krate.attrs, sym::compiler_builtins)
1048+
|| attr::contains_name(&krate.attrs, sym::no_core)
1049+
{
1050+
// `compiler_builtins` does not get extern builtins, nor do `#![no_core]` crates
1051+
info!("`compiler_builtins` unneeded");
1052+
return;
1053+
}
1054+
1055+
// let Some((cnum, _meta)) = self
1056+
// .cstore
1057+
// .iter_crate_data()
1058+
// .find(|(_cnum, meta)| meta.name() == sym::compiler_builtins)
1059+
// else {
1060+
// info!("`compiler_builtins` crate was not found for");
1061+
// return;
1062+
// };
1063+
//
1064+
info!("looking for builtins in {}", self.cstore.crate_name(LOCAL_CRATE));
1065+
1066+
// self.process_extern_crate(
1067+
// ast::ItemKind::ExternCrate(Some(sym::compiler_builtins)),
1068+
// def_id,
1069+
// definitions,
1070+
// )
1071+
1072+
let res = self.maybe_resolve_crate(
1073+
sym::compiler_builtins,
1074+
CrateDepKind::Explicit,
1075+
CrateOrigin::Injected,
1076+
);
1077+
1078+
info!("BUILTINS RESULT: {res:?}");
1079+
1080+
// let cnum = self
1081+
// .resolve_crate(
1082+
// sym::compiler_builtins,
1083+
// DUMMY_SP,
1084+
// CrateDepKind::Explicit,
1085+
// CrateOrigin::Injected,
1086+
// )
1087+
// .expect("unresolved builtins");
1088+
1089+
// self.cstore.update_extern_crate(cnum, ExternCrate {
1090+
// src: ExternCrateSource::Path,
1091+
// // src: ExternCrateSource::Extern(def_id.to_def_id()),
1092+
// span: DUMMY_SP,
1093+
// path_len: "compiler_builtins".len(),
1094+
// dependency_of: LOCAL_CRATE,
1095+
// });
1096+
1097+
// self.cstore.get_crate_data_mut(LOCAL_CRATE).add_dependency(cnum);
1098+
}
1099+
9811100
fn inject_dependency_if(
9821101
&mut self,
9831102
krate: CrateNum,
@@ -1087,6 +1206,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
10871206
}
10881207

10891208
pub fn postprocess(&mut self, krate: &ast::Crate) {
1209+
self.inject_compiler_builtins(krate);
10901210
self.inject_forced_externs();
10911211
self.inject_profiler_runtime();
10921212
self.inject_allocator_crate(krate);
@@ -1098,6 +1218,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
10981218
info!("{:?}", CrateDump(self.cstore));
10991219
}
11001220

1221+
/// Process an `extern crate foo` AST node.
11011222
pub fn process_extern_crate(
11021223
&mut self,
11031224
item: &ast::Item,
@@ -1123,7 +1244,11 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
11231244
CrateDepKind::Explicit
11241245
};
11251246

1126-
let cnum = self.resolve_crate(name, item.span, dep_kind)?;
1247+
let cnum =
1248+
self.resolve_crate(name, item.span, dep_kind, CrateOrigin::AstExtern {
1249+
name,
1250+
orig_name,
1251+
})?;
11271252

11281253
let path_len = definitions.def_path(def_id).data.len();
11291254
self.cstore.update_extern_crate(cnum, ExternCrate {
@@ -1139,7 +1264,8 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
11391264
}
11401265

11411266
pub fn process_path_extern(&mut self, name: Symbol, span: Span) -> Option<CrateNum> {
1142-
let cnum = self.resolve_crate(name, span, CrateDepKind::Explicit)?;
1267+
let cnum =
1268+
self.resolve_crate(name, span, CrateDepKind::Explicit, CrateOrigin::ExternPrelude)?;
11431269

11441270
self.cstore.update_extern_crate(cnum, ExternCrate {
11451271
src: ExternCrateSource::Path,
@@ -1153,7 +1279,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
11531279
}
11541280

11551281
pub fn maybe_process_path_extern(&mut self, name: Symbol) -> Option<CrateNum> {
1156-
self.maybe_resolve_crate(name, CrateDepKind::Explicit, None).ok()
1282+
self.maybe_resolve_crate(name, CrateDepKind::Explicit, CrateOrigin::ExternPrelude).ok()
11571283
}
11581284
}
11591285

0 commit comments

Comments
 (0)