From e90985acdec9928da9f6d157cfeb64f0ee98bffe Mon Sep 17 00:00:00 2001 From: Eduard-Mihai Burtescu Date: Fri, 28 Sep 2018 22:17:59 +0300 Subject: [PATCH] rustc_resolve: move extern_prelude from Resolver to Session. --- src/librustc/session/mod.rs | 19 ++++++++++++++++++- src/librustc_resolve/lib.rs | 20 +++----------------- src/librustc_resolve/macros.rs | 2 +- src/librustc_resolve/resolve_imports.rs | 6 +++--- 4 files changed, 25 insertions(+), 22 deletions(-) diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index be347253e7f..20d4ba9c632 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -38,7 +38,7 @@ use syntax::parse; use syntax::parse::ParseSess; use syntax::{ast, source_map}; use syntax::feature_gate::AttributeType; -use syntax_pos::{MultiSpan, Span}; +use syntax_pos::{MultiSpan, Span, symbol::Symbol}; use util::profiling::SelfProfiler; use rustc_target::spec::PanicStrategy; @@ -168,6 +168,10 @@ pub struct Session { /// Cap lint level specified by a driver specifically. pub driver_lint_caps: FxHashMap, + + /// All the crate names specified with `--extern`, and the builtin ones. + /// Starting with the Rust 2018 edition, absolute paths resolve in this set. + pub extern_prelude: FxHashSet, } pub struct PerfStats { @@ -1126,6 +1130,18 @@ pub fn build_session_( CguReuseTracker::new_disabled() }; + + let mut extern_prelude: FxHashSet = + sopts.externs.iter().map(|kv| Symbol::intern(kv.0)).collect(); + + // HACK(eddyb) this ignores the `no_{core,std}` attributes. + // FIXME(eddyb) warn (somewhere) if core/std is used with `no_{core,std}`. + // if !attr::contains_name(&krate.attrs, "no_core") { + // if !attr::contains_name(&krate.attrs, "no_std") { + extern_prelude.insert(Symbol::intern("core")); + extern_prelude.insert(Symbol::intern("std")); + extern_prelude.insert(Symbol::intern("meta")); + let sess = Session { target: target_cfg, host, @@ -1201,6 +1217,7 @@ pub fn build_session_( has_global_allocator: Once::new(), has_panic_handler: Once::new(), driver_lint_caps: FxHashMap(), + extern_prelude, }; validate_commandline_args_with_session_available(&sess); diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 91b0e9c1dca..7d5a6bb2a63 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -1350,7 +1350,6 @@ pub struct Resolver<'a, 'b: 'a> { graph_root: Module<'a>, prelude: Option>, - extern_prelude: FxHashSet, /// n.b. This is used only for better diagnostics, not name resolution itself. has_self: FxHashSet, @@ -1663,17 +1662,6 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { DefCollector::new(&mut definitions, Mark::root()) .collect_root(crate_name, session.local_crate_disambiguator()); - let mut extern_prelude: FxHashSet = - session.opts.externs.iter().map(|kv| Symbol::intern(kv.0)).collect(); - - // HACK(eddyb) this ignore the `no_{core,std}` attributes. - // FIXME(eddyb) warn (elsewhere) if core/std is used with `no_{core,std}`. - // if !attr::contains_name(&krate.attrs, "no_core") { - // if !attr::contains_name(&krate.attrs, "no_std") { - extern_prelude.insert(Symbol::intern("core")); - extern_prelude.insert(Symbol::intern("std")); - extern_prelude.insert(Symbol::intern("meta")); - let mut invocations = FxHashMap(); invocations.insert(Mark::root(), arenas.alloc_invocation_data(InvocationData::root(graph_root))); @@ -1692,7 +1680,6 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { // AST. graph_root, prelude: None, - extern_prelude, has_self: FxHashSet(), field_names: FxHashMap(), @@ -1963,7 +1950,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { if !module.no_implicit_prelude { // `record_used` means that we don't try to load crates during speculative resolution - if record_used && ns == TypeNS && self.extern_prelude.contains(&ident.name) { + if record_used && ns == TypeNS && self.session.extern_prelude.contains(&ident.name) { let crate_id = self.crate_loader.process_path_extern(ident.name, ident.span); let crate_root = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX }); self.populate_module_if_necessary(&crate_root); @@ -3955,7 +3942,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { } else { // Items from the prelude if !module.no_implicit_prelude { - names.extend(self.extern_prelude.iter().cloned()); + names.extend(self.session.extern_prelude.iter().cloned()); if let Some(prelude) = self.prelude { add_module_candidates(prelude, &mut names); } @@ -4401,8 +4388,7 @@ impl<'a, 'crateloader: 'a> Resolver<'a, 'crateloader> { ); if self.session.rust_2018() { - let extern_prelude_names = self.extern_prelude.clone(); - for &name in extern_prelude_names.iter() { + for &name in &self.session.extern_prelude { let ident = Ident::with_empty_ctxt(name); match self.crate_loader.maybe_process_path_extern(name, ident.span) { Some(crate_id) => { diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index ed79ff62f17..7b5e3ca078b 100644 --- a/src/librustc_resolve/macros.rs +++ b/src/librustc_resolve/macros.rs @@ -682,7 +682,7 @@ impl<'a, 'cl> Resolver<'a, 'cl> { result } WhereToResolve::ExternPrelude => { - if use_prelude && self.extern_prelude.contains(&ident.name) { + if use_prelude && self.session.extern_prelude.contains(&ident.name) { let crate_id = self.crate_loader.process_path_extern(ident.name, ident.span); let crate_root = diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index dc4a76db692..e689e6d70fd 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -199,7 +199,7 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> { if !( ns == TypeNS && !ident.is_path_segment_keyword() && - self.extern_prelude.contains(&ident.name) + self.session.extern_prelude.contains(&ident.name) ) { // ... unless the crate name is not in the `extern_prelude`. return binding; @@ -218,7 +218,7 @@ impl<'a, 'crateloader> Resolver<'a, 'crateloader> { } else if ns == TypeNS && !ident.is_path_segment_keyword() && - self.extern_prelude.contains(&ident.name) + self.session.extern_prelude.contains(&ident.name) { let crate_id = self.crate_loader.process_path_extern(ident.name, ident.span); @@ -735,7 +735,7 @@ impl<'a, 'b:'a, 'c: 'b> ImportResolver<'a, 'b, 'c> { let uniform_paths_feature = self.session.features_untracked().uniform_paths; for ((span, _, ns), results) in uniform_paths_canaries { let name = results.name; - let external_crate = if ns == TypeNS && self.extern_prelude.contains(&name) { + let external_crate = if ns == TypeNS && self.session.extern_prelude.contains(&name) { let crate_id = self.crate_loader.process_path_extern(name, span); Some(Def::Mod(DefId { krate: crate_id, index: CRATE_DEF_INDEX }))