bjoernager/rust
bjoernager/rust
1
Fork 0
Code Issues Pull requests Activity

Auto merge of #105462 - oli-obk:feeding_full, r=cjgillot,petrochenkov

Browse source 
give the resolver access to TyCtxt

The resolver is now created after TyCtxt is created. Then macro expansion and name resolution are run and the results fed into queries just like before this PR.

Since the resolver had (before this PR) mutable access to the `CStore` and the source span table, these two datastructures are now behind a `RwLock`. To ensure that these are not mutated anymore after the resolver is done, a read lock to them is leaked right after the resolver finishes.

### PRs split out of this one and leading up to it:

* https://github.com/rust-lang/rust/pull/105423
* https://github.com/rust-lang/rust/pull/105357
* https://github.com/rust-lang/rust/pull/105603
* https://github.com/rust-lang/rust/pull/106776
* https://github.com/rust-lang/rust/pull/106810
* https://github.com/rust-lang/rust/pull/106812
* https://github.com/rust-lang/rust/pull/108032
This commit is contained in:
bors 2023-02-21 01:19:25 +00:00
commit 2deff71719
35 changed files with 479 additions and 452 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Cargo.lock
View file

@ -4180,6 +4180,7 @@ dependencies = [
"rustc_hir_analysis", "rustc_hir_analysis",
"rustc_hir_typeck", "rustc_hir_typeck",
"rustc_incremental", "rustc_incremental",
"rustc_index",
"rustc_lint", "rustc_lint",
"rustc_macros", "rustc_macros",
"rustc_metadata", "rustc_metadata",

1
compiler/rustc_codegen_ssa/src/back/metadata.rs
View file

@ -33,6 +33,7 @@ use rustc_target::spec::{RelocModel, Target};
/// <dt>dylib</dt> /// <dt>dylib</dt>
/// <dd>The metadata can be found in the `.rustc` section of the shared library.</dd> /// <dd>The metadata can be found in the `.rustc` section of the shared library.</dd>
/// </dl> /// </dl>
#[derive(Debug)]
pub struct DefaultMetadataLoader; pub struct DefaultMetadataLoader;
fn load_metadata_with( fn load_metadata_with(

2
compiler/rustc_driver_impl/src/lib.rs
View file

@ -320,7 +320,7 @@ fn run_compiler(
} }
// Make sure name resolution and macro expansion is run. // Make sure name resolution and macro expansion is run.
queries.global_ctxt()?; queries.global_ctxt()?.enter(|tcx| tcx.resolver_for_lowering(()));
if callbacks.after_expansion(compiler, queries) == Compilation::Stop { if callbacks.after_expansion(compiler, queries) == Compilation::Stop {
return early_exit(); return early_exit();

6
compiler/rustc_expand/src/mbe/macro_rules.rs
View file

@ -16,7 +16,6 @@ use rustc_ast_pretty::pprust;
use rustc_attr::{self as attr, TransparencyError}; use rustc_attr::{self as attr, TransparencyError};
use rustc_data_structures::fx::{FxHashMap, FxIndexMap}; use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
use rustc_errors::{Applicability, ErrorGuaranteed}; use rustc_errors::{Applicability, ErrorGuaranteed};
use rustc_feature::Features;
use rustc_lint_defs::builtin::{ use rustc_lint_defs::builtin::{
RUST_2021_INCOMPATIBLE_OR_PATTERNS, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS, RUST_2021_INCOMPATIBLE_OR_PATTERNS, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
}; };
@ -379,7 +378,6 @@ pub(super) fn try_match_macro<'matcher, T: Tracker<'matcher>>(
/// Converts a macro item into a syntax extension. /// Converts a macro item into a syntax extension.
pub fn compile_declarative_macro( pub fn compile_declarative_macro(
sess: &Session, sess: &Session,
features: &Features,
def: &ast::Item, def: &ast::Item,
edition: Edition, edition: Edition,
) -> (SyntaxExtension, Vec<(usize, Span)>) { ) -> (SyntaxExtension, Vec<(usize, Span)>) {
@ -508,7 +506,7 @@ pub fn compile_declarative_macro(
true, true,
&sess.parse_sess, &sess.parse_sess,
def.id, def.id,
features, sess.features_untracked(),
edition, edition,
) )
.pop() .pop()
@ -532,7 +530,7 @@ pub fn compile_declarative_macro(
false, false,
&sess.parse_sess, &sess.parse_sess,
def.id, def.id,
features, sess.features_untracked(),
edition, edition,
) )
.pop() .pop()

1
compiler/rustc_interface/Cargo.toml
View file

@ -24,6 +24,7 @@ rustc_middle = { path = "../rustc_middle" }
rustc_ast_lowering = { path = "../rustc_ast_lowering" } rustc_ast_lowering = { path = "../rustc_ast_lowering" }
rustc_ast_passes = { path = "../rustc_ast_passes" } rustc_ast_passes = { path = "../rustc_ast_passes" }
rustc_incremental = { path = "../rustc_incremental" } rustc_incremental = { path = "../rustc_incremental" }
rustc_index = { path = "../rustc_index" }
rustc_traits = { path = "../rustc_traits" } rustc_traits = { path = "../rustc_traits" }
rustc_data_structures = { path = "../rustc_data_structures" } rustc_data_structures = { path = "../rustc_data_structures" }
rustc_codegen_ssa = { path = "../rustc_codegen_ssa" } rustc_codegen_ssa = { path = "../rustc_codegen_ssa" }

63
compiler/rustc_interface/src/passes.rs
View file

@ -8,11 +8,12 @@ use rustc_ast::{self as ast, visit};
use rustc_borrowck as mir_borrowck; use rustc_borrowck as mir_borrowck;
use rustc_codegen_ssa::traits::CodegenBackend; use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_data_structures::parallel; use rustc_data_structures::parallel;
use rustc_data_structures::steal::Steal;
use rustc_data_structures::sync::{Lrc, OnceCell, WorkerLocal}; use rustc_data_structures::sync::{Lrc, OnceCell, WorkerLocal};
use rustc_errors::{ErrorGuaranteed, PResult}; use rustc_errors::PResult;
use rustc_expand::base::{ExtCtxt, LintStoreExpand, ResolverExpand}; use rustc_expand::base::{ExtCtxt, LintStoreExpand, ResolverExpand};
use rustc_hir::def_id::{StableCrateId, LOCAL_CRATE}; use rustc_hir::def_id::{StableCrateId, LOCAL_CRATE};
use rustc_lint::{BufferedEarlyLint, EarlyCheckNode, LintStore}; use rustc_lint::{unerased_lint_store, BufferedEarlyLint, EarlyCheckNode, LintStore};
use rustc_metadata::creader::CStore; use rustc_metadata::creader::CStore;
use rustc_middle::arena::Arena; use rustc_middle::arena::Arena;
use rustc_middle::dep_graph::DepGraph; use rustc_middle::dep_graph::DepGraph;
@ -171,14 +172,12 @@ impl LintStoreExpand for LintStoreExpandImpl<'_> {
/// syntax expansion, secondary `cfg` expansion, synthesis of a test /// syntax expansion, secondary `cfg` expansion, synthesis of a test
/// harness if one is to be provided, injection of a dependency on the /// harness if one is to be provided, injection of a dependency on the
/// standard library and prelude, and name resolution. /// standard library and prelude, and name resolution.
pub fn configure_and_expand( #[instrument(level = "trace", skip(krate, resolver))]
sess: &Session, fn configure_and_expand(mut krate: ast::Crate, resolver: &mut Resolver<'_, '_>) -> ast::Crate {
lint_store: &LintStore, let tcx = resolver.tcx();
mut krate: ast::Crate, let sess = tcx.sess;
crate_name: Symbol, let lint_store = unerased_lint_store(tcx);
resolver: &mut Resolver<'_, '_>, let crate_name = tcx.crate_name(LOCAL_CRATE);
) -> Result<ast::Crate> {
trace!("configure_and_expand");
pre_expansion_lint(sess, lint_store, resolver.registered_tools(), &krate, crate_name); pre_expansion_lint(sess, lint_store, resolver.registered_tools(), &krate, crate_name);
rustc_builtin_macros::register_builtin_macros(resolver); rustc_builtin_macros::register_builtin_macros(resolver);
@ -249,20 +248,19 @@ pub fn configure_and_expand(
ecx.check_unused_macros(); ecx.check_unused_macros();
}); });
let recursion_limit_hit = ecx.reduced_recursion_limit.is_some(); // If we hit a recursion limit, exit early to avoid later passes getting overwhelmed
// with a large AST
if ecx.reduced_recursion_limit.is_some() {
sess.abort_if_errors();
unreachable!();
}
if cfg!(windows) { if cfg!(windows) {
env::set_var("PATH", &old_path); env::set_var("PATH", &old_path);
} }
if recursion_limit_hit { krate
// If we hit a recursion limit, exit early to avoid later passes getting overwhelmed });
// with a large AST
Err(ErrorGuaranteed::unchecked_claim_error_was_emitted())
} else {
Ok(krate)
}
})?;
sess.time("maybe_building_test_harness", || { sess.time("maybe_building_test_harness", || {
rustc_builtin_macros::test_harness::inject(sess, resolver, &mut krate) rustc_builtin_macros::test_harness::inject(sess, resolver, &mut krate)
@ -365,7 +363,7 @@ pub fn configure_and_expand(
) )
}); });
Ok(krate) krate
} }
// Returns all the paths that correspond to generated files. // Returns all the paths that correspond to generated files.
@ -564,6 +562,28 @@ fn write_out_deps(
} }
} }
fn resolver_for_lowering<'tcx>(
tcx: TyCtxt<'tcx>,
(): (),
) -> &'tcx Steal<(ty::ResolverAstLowering, Lrc<ast::Crate>)> {
let arenas = Resolver::arenas();
let krate = tcx.crate_for_resolver(()).steal();
let mut resolver = Resolver::new(tcx, &krate, &arenas);
let krate = configure_and_expand(krate, &mut resolver);
// Make sure we don't mutate the cstore from here on.
tcx.untracked().cstore.leak();
let ty::ResolverOutputs {
global_ctxt: untracked_resolutions,
ast_lowering: untracked_resolver_for_lowering,
} = resolver.into_outputs();
let feed = tcx.feed_unit_query();
feed.resolutions(tcx.arena.alloc(untracked_resolutions));
tcx.arena.alloc(Steal::new((untracked_resolver_for_lowering, Lrc::new(krate))))
}
fn output_filenames(tcx: TyCtxt<'_>, (): ()) -> Arc<OutputFilenames> { fn output_filenames(tcx: TyCtxt<'_>, (): ()) -> Arc<OutputFilenames> {
let sess = tcx.sess; let sess = tcx.sess;
let _timer = sess.timer("prepare_outputs"); let _timer = sess.timer("prepare_outputs");
@ -597,7 +617,7 @@ fn output_filenames(tcx: TyCtxt<'_>, (): ()) -> Arc<OutputFilenames> {
} }
} }
write_out_deps(sess, tcx.cstore_untracked(), &outputs, &output_paths); write_out_deps(sess, &*tcx.cstore_untracked(), &outputs, &output_paths);
let only_dep_info = sess.opts.output_types.contains_key(&OutputType::DepInfo) let only_dep_info = sess.opts.output_types.contains_key(&OutputType::DepInfo)
&& sess.opts.output_types.len() == 1; && sess.opts.output_types.len() == 1;
@ -618,6 +638,7 @@ pub static DEFAULT_QUERY_PROVIDERS: LazyLock<Providers> = LazyLock::new(|| {
providers.analysis = analysis; providers.analysis = analysis;
providers.hir_crate = rustc_ast_lowering::lower_to_hir; providers.hir_crate = rustc_ast_lowering::lower_to_hir;
providers.output_filenames = output_filenames; providers.output_filenames = output_filenames;
providers.resolver_for_lowering = resolver_for_lowering;
proc_macro_decls::provide(providers); proc_macro_decls::provide(providers);
rustc_const_eval::provide(providers); rustc_const_eval::provide(providers);
rustc_middle::hir::provide(providers); rustc_middle::hir::provide(providers);

63
compiler/rustc_interface/src/queries.rs
View file

@ -7,16 +7,19 @@ use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_codegen_ssa::CodegenResults; use rustc_codegen_ssa::CodegenResults;
use rustc_data_structures::steal::Steal; use rustc_data_structures::steal::Steal;
use rustc_data_structures::svh::Svh; use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::{Lrc, OnceCell, WorkerLocal}; use rustc_data_structures::sync::{Lrc, OnceCell, RwLock, WorkerLocal};
use rustc_hir::def_id::LOCAL_CRATE; use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE};
use rustc_hir::definitions::Definitions;
use rustc_incremental::DepGraphFuture; use rustc_incremental::DepGraphFuture;
use rustc_index::vec::IndexVec;
use rustc_lint::LintStore; use rustc_lint::LintStore;
use rustc_metadata::creader::CStore;
use rustc_middle::arena::Arena; use rustc_middle::arena::Arena;
use rustc_middle::dep_graph::DepGraph; use rustc_middle::dep_graph::DepGraph;
use rustc_middle::ty::{self, GlobalCtxt, TyCtxt}; use rustc_middle::ty::{GlobalCtxt, TyCtxt};
use rustc_query_impl::Queries as TcxQueries; use rustc_query_impl::Queries as TcxQueries;
use rustc_resolve::Resolver;
use rustc_session::config::{self, OutputFilenames, OutputType}; use rustc_session::config::{self, OutputFilenames, OutputType};
use rustc_session::cstore::Untracked;
use rustc_session::{output::find_crate_name, Session}; use rustc_session::{output::find_crate_name, Session};
use rustc_span::symbol::sym; use rustc_span::symbol::sym;
use rustc_span::Symbol; use rustc_span::Symbol;
@ -187,35 +190,18 @@ impl<'tcx> Queries<'tcx> {
self.gcx.compute(|| { self.gcx.compute(|| {
let crate_name = *self.crate_name()?.borrow(); let crate_name = *self.crate_name()?.borrow();
let (krate, lint_store) = self.register_plugins()?.steal(); let (krate, lint_store) = self.register_plugins()?.steal();
let (krate, resolver_outputs) = {
let _timer = self.session().timer("configure_and_expand");
let sess = self.session();
let arenas = Resolver::arenas(); let sess = self.session();
let mut resolver = Resolver::new(
sess,
&krate,
crate_name,
self.codegen_backend().metadata_loader(),
&arenas,
);
let krate = passes::configure_and_expand(
sess,
&lint_store,
krate,
crate_name,
&mut resolver,
)?;
(Lrc::new(krate), resolver.into_outputs())
};
let ty::ResolverOutputs { let cstore = RwLock::new(Box::new(CStore::new(sess)) as _);
untracked, let definitions = RwLock::new(Definitions::new(sess.local_stable_crate_id()));
global_ctxt: untracked_resolutions, let mut source_span = IndexVec::default();
ast_lowering: untracked_resolver_for_lowering, let _id = source_span.push(krate.spans.inner_span);
} = resolver_outputs; debug_assert_eq!(_id, CRATE_DEF_ID);
let source_span = RwLock::new(source_span);
let untracked = Untracked { cstore, source_span, definitions };
let gcx = passes::create_global_ctxt( let qcx = passes::create_global_ctxt(
self.compiler, self.compiler,
lint_store, lint_store,
self.dep_graph()?.steal(), self.dep_graph()?.steal(),
@ -226,17 +212,18 @@ impl<'tcx> Queries<'tcx> {
&self.hir_arena, &self.hir_arena,
); );
gcx.enter(|tcx| { qcx.enter(|tcx| {
let feed = tcx.feed_unit_query();
feed.resolver_for_lowering(
tcx.arena.alloc(Steal::new((untracked_resolver_for_lowering, krate))),
);
feed.resolutions(tcx.arena.alloc(untracked_resolutions));
feed.features_query(tcx.sess.features_untracked());
let feed = tcx.feed_local_crate(); let feed = tcx.feed_local_crate();
feed.crate_name(crate_name); feed.crate_name(crate_name);
let feed = tcx.feed_unit_query();
feed.crate_for_resolver(tcx.arena.alloc(Steal::new(krate)));
feed.metadata_loader(
tcx.arena.alloc(Steal::new(self.codegen_backend().metadata_loader())),
);
feed.features_query(tcx.sess.features_untracked());
}); });
Ok(gcx) Ok(qcx)
}) })
} }

52
compiler/rustc_metadata/src/creader.rs
View file

@ -8,15 +8,15 @@ use rustc_ast::expand::allocator::AllocatorKind;
use rustc_ast::{self as ast, *}; use rustc_ast::{self as ast, *};
use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_data_structures::fx::{FxHashMap, FxHashSet};
use rustc_data_structures::svh::Svh; use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::ReadGuard; use rustc_data_structures::sync::MappedReadGuard;
use rustc_expand::base::SyntaxExtension; use rustc_expand::base::SyntaxExtension;
use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, LOCAL_CRATE}; use rustc_hir::def_id::{CrateNum, LocalDefId, StableCrateId, LOCAL_CRATE};
use rustc_hir::definitions::Definitions; use rustc_hir::definitions::Definitions;
use rustc_index::vec::IndexVec; use rustc_index::vec::IndexVec;
use rustc_middle::ty::TyCtxt; use rustc_middle::ty::TyCtxt;
use rustc_session::config::{self, CrateType, ExternLocation}; use rustc_session::config::{self, CrateType, ExternLocation};
use rustc_session::cstore::ExternCrateSource;
use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate}; use rustc_session::cstore::{CrateDepKind, CrateSource, ExternCrate};
use rustc_session::cstore::{ExternCrateSource, MetadataLoaderDyn};
use rustc_session::lint; use rustc_session::lint;
use rustc_session::output::validate_crate_name; use rustc_session::output::validate_crate_name;
use rustc_session::search_paths::PathKind; use rustc_session::search_paths::PathKind;
@ -60,17 +60,22 @@ impl std::fmt::Debug for CStore {
} }
} }
pub struct CrateLoader<'a> { pub struct CrateLoader<'a, 'tcx: 'a> {
// Immutable configuration. // Immutable configuration.
sess: &'a Session, tcx: TyCtxt<'tcx>,
metadata_loader: &'a MetadataLoaderDyn,
definitions: ReadGuard<'a, Definitions>,
local_crate_name: Symbol,
// Mutable output. // Mutable output.
cstore: &'a mut CStore, cstore: &'a mut CStore,
used_extern_options: &'a mut FxHashSet<Symbol>, used_extern_options: &'a mut FxHashSet<Symbol>,
} }
impl<'a, 'tcx> std::ops::Deref for CrateLoader<'a, 'tcx> {
type Target = TyCtxt<'tcx>;
fn deref(&self) -> &Self::Target {
&self.tcx
}
}
pub enum LoadedMacro { pub enum LoadedMacro {
MacroDef(ast::Item, Edition), MacroDef(ast::Item, Edition),
ProcMacro(SyntaxExtension), ProcMacro(SyntaxExtension),
@ -127,11 +132,10 @@ impl<'a> std::fmt::Debug for CrateDump<'a> {
} }
impl CStore { impl CStore {
pub fn from_tcx(tcx: TyCtxt<'_>) -> &CStore { pub fn from_tcx(tcx: TyCtxt<'_>) -> MappedReadGuard<'_, CStore> {
tcx.cstore_untracked() MappedReadGuard::map(tcx.cstore_untracked(), |c| {
.as_any() c.as_any().downcast_ref::<CStore>().expect("`tcx.cstore` is not a `CStore`")
.downcast_ref::<CStore>() })
.expect("`tcx.cstore` is not a `CStore`")
} }
fn alloc_new_crate_num(&mut self) -> CrateNum { fn alloc_new_crate_num(&mut self) -> CrateNum {
@ -256,23 +260,13 @@ impl CStore {
} }
} }
impl<'a> CrateLoader<'a> { impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
pub fn new( pub fn new(
sess: &'a Session, tcx: TyCtxt<'tcx>,
metadata_loader: &'a MetadataLoaderDyn,
local_crate_name: Symbol,
cstore: &'a mut CStore, cstore: &'a mut CStore,
definitions: ReadGuard<'a, Definitions>,
used_extern_options: &'a mut FxHashSet<Symbol>, used_extern_options: &'a mut FxHashSet<Symbol>,
) -> Self { ) -> Self {
CrateLoader { CrateLoader { tcx, cstore, used_extern_options }
sess,
metadata_loader,
local_crate_name,
cstore,
used_extern_options,
definitions,
}
} }
pub fn cstore(&self) -> &CStore { pub fn cstore(&self) -> &CStore {
&self.cstore &self.cstore
@ -563,9 +557,10 @@ impl<'a> CrateLoader<'a> {
(LoadResult::Previous(cnum), None) (LoadResult::Previous(cnum), None)
} else { } else {
info!("falling back to a load"); info!("falling back to a load");
let metadata_loader = self.tcx.metadata_loader(()).borrow();
let mut locator = CrateLocator::new( let mut locator = CrateLocator::new(
self.sess, self.sess,
&*self.metadata_loader, &**metadata_loader,
name, name,
hash, hash,
extra_filename, extra_filename,
@ -970,7 +965,7 @@ impl<'a> CrateLoader<'a> {
&format!( &format!(
"external crate `{}` unused in `{}`: remove the dependency or add `use {} as _;`", "external crate `{}` unused in `{}`: remove the dependency or add `use {} as _;`",
name, name,
self.local_crate_name, self.tcx.crate_name(LOCAL_CRATE),
name), name),
); );
} }
@ -990,6 +985,7 @@ impl<'a> CrateLoader<'a> {
&mut self, &mut self,
item: &ast::Item, item: &ast::Item,
def_id: LocalDefId, def_id: LocalDefId,
definitions: &Definitions,
) -> Option<CrateNum> { ) -> Option<CrateNum> {
match item.kind { match item.kind {
ast::ItemKind::ExternCrate(orig_name) => { ast::ItemKind::ExternCrate(orig_name) => {
@ -1012,7 +1008,7 @@ impl<'a> CrateLoader<'a> {
let cnum = self.resolve_crate(name, item.span, dep_kind)?; let cnum = self.resolve_crate(name, item.span, dep_kind)?;
let path_len = self.definitions.def_path(def_id).data.len(); let path_len = definitions.def_path(def_id).data.len();
self.update_extern_crate( self.update_extern_crate(
cnum, cnum,
ExternCrate { ExternCrate {

8
compiler/rustc_metadata/src/rmeta/decoder/cstore_impl.rs
View file

@ -130,7 +130,13 @@ macro_rules! provide_one {
$tcx.ensure().crate_hash($def_id.krate); $tcx.ensure().crate_hash($def_id.krate);
} }
let $cdata = CStore::from_tcx($tcx).get_crate_data($def_id.krate); let cdata = rustc_data_structures::sync::MappedReadGuard::map(CStore::from_tcx($tcx), |c| {
c.get_crate_data($def_id.krate).cdata
});
let $cdata = crate::creader::CrateMetadataRef {
cdata: &cdata,
cstore: &CStore::from_tcx($tcx),
};
$compute $compute
} }

2
compiler/rustc_middle/src/arena.rs
View file

@ -35,6 +35,8 @@ macro_rules! arena_types {
rustc_data_structures::sync::Lrc<rustc_ast::Crate>, rustc_data_structures::sync::Lrc<rustc_ast::Crate>,
)>, )>,
[] output_filenames: std::sync::Arc<rustc_session::config::OutputFilenames>, [] output_filenames: std::sync::Arc<rustc_session::config::OutputFilenames>,
[] metadata_loader: rustc_data_structures::steal::Steal<Box<rustc_session::cstore::MetadataLoaderDyn>>,
[] crate_for_resolver: rustc_data_structures::steal::Steal<rustc_ast::ast::Crate>,
[] resolutions: rustc_middle::ty::ResolverGlobalCtxt, [] resolutions: rustc_middle::ty::ResolverGlobalCtxt,
[decode] unsafety_check_result: rustc_middle::mir::UnsafetyCheckResult, [decode] unsafety_check_result: rustc_middle::mir::UnsafetyCheckResult,
[decode] code_region: rustc_middle::mir::coverage::CodeRegion, [decode] code_region: rustc_middle::mir::coverage::CodeRegion,

25
compiler/rustc_middle/src/middle/privacy.rs
View file

@ -194,11 +194,6 @@ impl EffectiveVisibilities {
} }
} }
pub trait IntoDefIdTree {
type Tree: DefIdTree;
fn tree(self) -> Self::Tree;
}
impl<Id: Eq + Hash> EffectiveVisibilities<Id> { impl<Id: Eq + Hash> EffectiveVisibilities<Id> {
pub fn iter(&self) -> impl Iterator<Item = (&Id, &EffectiveVisibility)> { pub fn iter(&self) -> impl Iterator<Item = (&Id, &EffectiveVisibility)> {
self.map.iter() self.map.iter()
@ -217,25 +212,21 @@ impl<Id: Eq + Hash> EffectiveVisibilities<Id> {
self.map.entry(id).or_insert_with(|| EffectiveVisibility::from_vis(lazy_private_vis())) self.map.entry(id).or_insert_with(|| EffectiveVisibility::from_vis(lazy_private_vis()))
} }
pub fn update<T: IntoDefIdTree>( pub fn update(
&mut self, &mut self,
id: Id, id: Id,
nominal_vis: Visibility, nominal_vis: Visibility,
lazy_private_vis: impl FnOnce(T) -> (Visibility, T), lazy_private_vis: impl FnOnce() -> Visibility,
inherited_effective_vis: EffectiveVisibility, inherited_effective_vis: EffectiveVisibility,
level: Level, level: Level,
mut into_tree: T, tree: impl DefIdTree,
) -> bool { ) -> bool {
let mut changed = false; let mut changed = false;
let mut current_effective_vis = match self.map.get(&id).copied() { let mut current_effective_vis = self
Some(eff_vis) => eff_vis, .map
None => { .get(&id)
let private_vis; .copied()
(private_vis, into_tree) = lazy_private_vis(into_tree); .unwrap_or_else(|| EffectiveVisibility::from_vis(lazy_private_vis()));
EffectiveVisibility::from_vis(private_vis)
}
};
let tree = into_tree.tree();
let mut inherited_effective_vis_at_prev_level = *inherited_effective_vis.at_level(level); let mut inherited_effective_vis_at_prev_level = *inherited_effective_vis.at_level(level);
let mut calculated_effective_vis = inherited_effective_vis_at_prev_level; let mut calculated_effective_vis = inherited_effective_vis_at_prev_level;

14
compiler/rustc_middle/src/query/mod.rs
View file

@ -33,7 +33,7 @@ rustc_queries! {
} }
query resolver_for_lowering(_: ()) -> &'tcx Steal<(ty::ResolverAstLowering, Lrc<ast::Crate>)> { query resolver_for_lowering(_: ()) -> &'tcx Steal<(ty::ResolverAstLowering, Lrc<ast::Crate>)> {
feedable eval_always
no_hash no_hash
desc { "getting the resolver for lowering" } desc { "getting the resolver for lowering" }
} }
@ -2077,6 +2077,18 @@ rustc_queries! {
desc { "looking up enabled feature gates" } desc { "looking up enabled feature gates" }
} }
query metadata_loader((): ()) -> &'tcx Steal<Box<rustc_session::cstore::MetadataLoaderDyn>> {
feedable
no_hash
desc { "raw operations for metadata file access" }
}
query crate_for_resolver((): ()) -> &'tcx Steal<rustc_ast::ast::Crate> {
feedable
no_hash
desc { "the ast before macro expansion and name resolution" }
}
/// Attempt to resolve the given `DefId` to an `Instance`, for the /// Attempt to resolve the given `DefId` to an `Instance`, for the
/// given generics args (`SubstsRef`), returning one of: /// given generics args (`SubstsRef`), returning one of:
/// * `Ok(Some(instance))` on success /// * `Ok(Some(instance))` on success

28
compiler/rustc_middle/src/ty/context.rs
View file

@ -36,7 +36,7 @@ use rustc_data_structures::profiling::SelfProfilerRef;
use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap}; use rustc_data_structures::sharded::{IntoPointer, ShardedHashMap};
use rustc_data_structures::stable_hasher::{HashStable, StableHasher}; use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
use rustc_data_structures::steal::Steal; use rustc_data_structures::steal::Steal;
use rustc_data_structures::sync::{self, Lock, Lrc, ReadGuard, WorkerLocal}; use rustc_data_structures::sync::{self, Lock, Lrc, MappedReadGuard, ReadGuard, WorkerLocal};
use rustc_errors::{ use rustc_errors::{
DecorateLint, DiagnosticBuilder, DiagnosticMessage, ErrorGuaranteed, MultiSpan, DecorateLint, DiagnosticBuilder, DiagnosticMessage, ErrorGuaranteed, MultiSpan,
}; };
@ -836,7 +836,7 @@ impl<'tcx> TyCtxt<'tcx> {
if let Some(id) = id.as_local() { if let Some(id) = id.as_local() {
self.definitions_untracked().def_key(id) self.definitions_untracked().def_key(id)
} else { } else {
self.untracked.cstore.def_key(id) self.cstore_untracked().def_key(id)
} }
} }
@ -850,7 +850,7 @@ impl<'tcx> TyCtxt<'tcx> {
if let Some(id) = id.as_local() { if let Some(id) = id.as_local() {
self.definitions_untracked().def_path(id) self.definitions_untracked().def_path(id)
} else { } else {
self.untracked.cstore.def_path(id) self.cstore_untracked().def_path(id)
} }
} }
@ -860,7 +860,7 @@ impl<'tcx> TyCtxt<'tcx> {
if let Some(def_id) = def_id.as_local() { if let Some(def_id) = def_id.as_local() {
self.definitions_untracked().def_path_hash(def_id) self.definitions_untracked().def_path_hash(def_id)
} else { } else {
self.untracked.cstore.def_path_hash(def_id) self.cstore_untracked().def_path_hash(def_id)
} }
} }
@ -869,7 +869,7 @@ impl<'tcx> TyCtxt<'tcx> {
if crate_num == LOCAL_CRATE { if crate_num == LOCAL_CRATE {
self.sess.local_stable_crate_id() self.sess.local_stable_crate_id()
} else { } else {
self.untracked.cstore.stable_crate_id(crate_num) self.cstore_untracked().stable_crate_id(crate_num)
} }
} }
@ -880,7 +880,7 @@ impl<'tcx> TyCtxt<'tcx> {
if stable_crate_id == self.sess.local_stable_crate_id() { if stable_crate_id == self.sess.local_stable_crate_id() {
LOCAL_CRATE LOCAL_CRATE
} else { } else {
self.untracked.cstore.stable_crate_id_to_crate_num(stable_crate_id) self.cstore_untracked().stable_crate_id_to_crate_num(stable_crate_id)
} }
} }
@ -899,7 +899,7 @@ impl<'tcx> TyCtxt<'tcx> {
} else { } else {
// If this is a DefPathHash from an upstream crate, let the CrateStore map // If this is a DefPathHash from an upstream crate, let the CrateStore map
// it to a DefId. // it to a DefId.
let cstore = &*self.untracked.cstore; let cstore = &*self.cstore_untracked();
let cnum = cstore.stable_crate_id_to_crate_num(stable_crate_id); let cnum = cstore.stable_crate_id_to_crate_num(stable_crate_id);
cstore.def_path_hash_to_def_id(cnum, hash) cstore.def_path_hash_to_def_id(cnum, hash)
} }
@ -913,7 +913,7 @@ impl<'tcx> TyCtxt<'tcx> {
let (crate_name, stable_crate_id) = if def_id.is_local() { let (crate_name, stable_crate_id) = if def_id.is_local() {
(self.crate_name(LOCAL_CRATE), self.sess.local_stable_crate_id()) (self.crate_name(LOCAL_CRATE), self.sess.local_stable_crate_id())
} else { } else {
let cstore = &*self.untracked.cstore; let cstore = &*self.cstore_untracked();
(cstore.crate_name(def_id.krate), cstore.stable_crate_id(def_id.krate)) (cstore.crate_name(def_id.krate), cstore.stable_crate_id(def_id.krate))
}; };
@ -1011,10 +1011,14 @@ impl<'tcx> TyCtxt<'tcx> {
/// Note that this is *untracked* and should only be used within the query /// Note that this is *untracked* and should only be used within the query
/// system if the result is otherwise tracked through queries /// system if the result is otherwise tracked through queries
pub fn cstore_untracked(self) -> &'tcx CrateStoreDyn { pub fn cstore_untracked(self) -> MappedReadGuard<'tcx, CrateStoreDyn> {
&*self.untracked.cstore ReadGuard::map(self.untracked.cstore.read(), |c| &**c)
} }
/// Give out access to the untracked data without any sanity checks.
pub fn untracked(self) -> &'tcx Untracked {
&self.untracked
}
/// Note that this is *untracked* and should only be used within the query /// Note that this is *untracked* and should only be used within the query
/// system if the result is otherwise tracked through queries /// system if the result is otherwise tracked through queries
#[inline] #[inline]
@ -1026,7 +1030,7 @@ impl<'tcx> TyCtxt<'tcx> {
/// system if the result is otherwise tracked through queries /// system if the result is otherwise tracked through queries
#[inline] #[inline]
pub fn source_span_untracked(self, def_id: LocalDefId) -> Span { pub fn source_span_untracked(self, def_id: LocalDefId) -> Span {
self.untracked.source_span.get(def_id).copied().unwrap_or(DUMMY_SP) self.untracked.source_span.read().get(def_id).copied().unwrap_or(DUMMY_SP)
} }
#[inline(always)] #[inline(always)]
@ -2518,5 +2522,5 @@ pub fn provide(providers: &mut ty::query::Providers) {
tcx.lang_items().panic_impl().map_or(false, |did| did.is_local()) tcx.lang_items().panic_impl().map_or(false, |did| did.is_local())
}; };
providers.source_span = providers.source_span =
|tcx, def_id| tcx.untracked.source_span.get(def_id).copied().unwrap_or(DUMMY_SP); |tcx, def_id| tcx.untracked.source_span.read().get(def_id).copied().unwrap_or(DUMMY_SP);
} }

2
compiler/rustc_middle/src/ty/mod.rs
View file

@ -43,7 +43,6 @@ use rustc_index::vec::IndexVec;
use rustc_macros::HashStable; use rustc_macros::HashStable;
use rustc_query_system::ich::StableHashingContext; use rustc_query_system::ich::StableHashingContext;
use rustc_serialize::{Decodable, Encodable}; use rustc_serialize::{Decodable, Encodable};
use rustc_session::cstore::Untracked;
use rustc_span::hygiene::MacroKind; use rustc_span::hygiene::MacroKind;
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
use rustc_span::{ExpnId, ExpnKind, Span}; use rustc_span::{ExpnId, ExpnKind, Span};
@ -157,7 +156,6 @@ pub type RegisteredTools = FxHashSet<Ident>;
pub struct ResolverOutputs { pub struct ResolverOutputs {
pub global_ctxt: ResolverGlobalCtxt, pub global_ctxt: ResolverGlobalCtxt,
pub ast_lowering: ResolverAstLowering, pub ast_lowering: ResolverAstLowering,
pub untracked: Untracked,
} }
#[derive(Debug)] #[derive(Debug)]

4
compiler/rustc_query_system/src/ich/hcx.rs
View file

@ -90,7 +90,7 @@ impl<'a> StableHashingContext<'a> {
if let Some(def_id) = def_id.as_local() { if let Some(def_id) = def_id.as_local() {
self.local_def_path_hash(def_id) self.local_def_path_hash(def_id)
} else { } else {
self.untracked.cstore.def_path_hash(def_id) self.untracked.cstore.read().def_path_hash(def_id)
} }
} }
@ -146,7 +146,7 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
#[inline] #[inline]
fn def_span(&self, def_id: LocalDefId) -> Span { fn def_span(&self, def_id: LocalDefId) -> Span {
*self.untracked.source_span.get(def_id).unwrap_or(&DUMMY_SP) *self.untracked.source_span.read().get(def_id).unwrap_or(&DUMMY_SP)
} }
#[inline] #[inline]

82
compiler/rustc_resolve/src/build_reduced_graph.rs
View file

@ -130,11 +130,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
def_key.disambiguated_data.data.get_opt_name().expect("module without name") def_key.disambiguated_data.data.get_opt_name().expect("module without name")
}; };
let expn_id = self.cstore().module_expansion_untracked(def_id, &self.tcx.sess);
let span = self.cstore().get_span_untracked(def_id, &self.tcx.sess);
Some(self.new_module( Some(self.new_module(
parent, parent,
ModuleKind::Def(def_kind, def_id, name), ModuleKind::Def(def_kind, def_id, name),
self.cstore().module_expansion_untracked(def_id, &self.session), expn_id,
self.cstore().get_span_untracked(def_id, &self.session), span,
// FIXME: Account for `#[no_implicit_prelude]` attributes. // FIXME: Account for `#[no_implicit_prelude]` attributes.
parent.map_or(false, |module| module.no_implicit_prelude), parent.map_or(false, |module| module.no_implicit_prelude),
)) ))
@ -179,7 +181,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
return macro_data.clone(); return macro_data.clone();
} }
let (ext, macro_rules) = match self.cstore().load_macro_untracked(def_id, &self.session) { let load_macro_untracked = self.cstore().load_macro_untracked(def_id, &self.tcx.sess);
let (ext, macro_rules) = match load_macro_untracked {
LoadedMacro::MacroDef(item, edition) => ( LoadedMacro::MacroDef(item, edition) => (
Lrc::new(self.compile_macro(&item, edition).0), Lrc::new(self.compile_macro(&item, edition).0),
matches!(item.kind, ItemKind::MacroDef(def) if def.macro_rules), matches!(item.kind, ItemKind::MacroDef(def) if def.macro_rules),
@ -204,9 +207,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
pub(crate) fn build_reduced_graph_external(&mut self, module: Module<'a>) { pub(crate) fn build_reduced_graph_external(&mut self, module: Module<'a>) {
for child in let children =
Vec::from_iter(self.cstore().module_children_untracked(module.def_id(), self.session)) Vec::from_iter(self.cstore().module_children_untracked(module.def_id(), self.tcx.sess));
{ for child in children {
let parent_scope = ParentScope::module(module, self); let parent_scope = ParentScope::module(module, self);
BuildReducedGraphVisitor { r: self, parent_scope } BuildReducedGraphVisitor { r: self, parent_scope }
.build_reduced_graph_for_external_crate_res(child); .build_reduced_graph_for_external_crate_res(child);
@ -346,7 +349,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
fn insert_field_names_extern(&mut self, def_id: DefId) { fn insert_field_names_extern(&mut self, def_id: DefId) {
let field_names = let field_names =
self.r.cstore().struct_field_names_untracked(def_id, self.r.session).collect(); self.r.cstore().struct_field_names_untracked(def_id, self.r.tcx.sess).collect();
self.r.field_names.insert(def_id, field_names); self.r.field_names.insert(def_id, field_names);
} }
@ -539,14 +542,15 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
} }
self.r self.r
.session .tcx
.sess
.struct_span_err(item.span, "`$crate` may not be imported") .struct_span_err(item.span, "`$crate` may not be imported")
.emit(); .emit();
} }
} }
if ident.name == kw::Crate { if ident.name == kw::Crate {
self.r.session.span_err( self.r.tcx.sess.span_err(
ident.span, ident.span,
"crate root imports need to be explicitly named: \ "crate root imports need to be explicitly named: \
`use crate as name;`", `use crate as name;`",
@ -575,7 +579,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
} }
ast::UseTreeKind::Glob => { ast::UseTreeKind::Glob => {
let kind = ImportKind::Glob { let kind = ImportKind::Glob {
is_prelude: self.r.session.contains_name(&item.attrs, sym::prelude_import), is_prelude: self.r.tcx.sess.contains_name(&item.attrs, sym::prelude_import),
max_vis: Cell::new(None), max_vis: Cell::new(None),
id, id,
}; };
@ -690,7 +694,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
expansion.to_expn_id(), expansion.to_expn_id(),
item.span, item.span,
parent.no_implicit_prelude parent.no_implicit_prelude
|| self.r.session.contains_name(&item.attrs, sym::no_implicit_prelude), || self.r.tcx.sess.contains_name(&item.attrs, sym::no_implicit_prelude),
); );
self.r.define(parent, ident, TypeNS, (module, vis, sp, expansion)); self.r.define(parent, ident, TypeNS, (module, vis, sp, expansion));
@ -755,7 +759,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
// If the structure is marked as non_exhaustive then lower the visibility // If the structure is marked as non_exhaustive then lower the visibility
// to within the crate. // to within the crate.
let mut ctor_vis = if vis.is_public() let mut ctor_vis = if vis.is_public()
&& self.r.session.contains_name(&item.attrs, sym::non_exhaustive) && self.r.tcx.sess.contains_name(&item.attrs, sym::non_exhaustive)
{ {
ty::Visibility::Restricted(CRATE_DEF_ID) ty::Visibility::Restricted(CRATE_DEF_ID)
} else { } else {
@ -837,7 +841,8 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
let (used, module, binding) = if orig_name.is_none() && ident.name == kw::SelfLower { let (used, module, binding) = if orig_name.is_none() && ident.name == kw::SelfLower {
self.r self.r
.session .tcx
.sess
.struct_span_err(item.span, "`extern crate self;` requires renaming") .struct_span_err(item.span, "`extern crate self;` requires renaming")
.span_suggestion( .span_suggestion(
item.span, item.span,
@ -850,7 +855,10 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
} else if orig_name == Some(kw::SelfLower) { } else if orig_name == Some(kw::SelfLower) {
Some(self.r.graph_root) Some(self.r.graph_root)
} else { } else {
let crate_id = self.r.crate_loader().process_extern_crate(item, local_def_id); let tcx = self.r.tcx;
let crate_id = self.r.crate_loader(|c| {
c.process_extern_crate(item, local_def_id, &tcx.definitions_untracked())
});
crate_id.map(|crate_id| { crate_id.map(|crate_id| {
self.r.extern_crate_map.insert(local_def_id, crate_id); self.r.extern_crate_map.insert(local_def_id, crate_id);
self.r.expect_module(crate_id.as_def_id()) self.r.expect_module(crate_id.as_def_id())
@ -887,7 +895,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
{ {
let msg = "macro-expanded `extern crate` items cannot \ let msg = "macro-expanded `extern crate` items cannot \
shadow names passed with `--extern`"; shadow names passed with `--extern`";
self.r.session.span_err(item.span, msg); self.r.tcx.sess.span_err(item.span, msg);
} }
} }
let entry = self.r.extern_prelude.entry(ident.normalize_to_macros_2_0()).or_insert( let entry = self.r.extern_prelude.entry(ident.normalize_to_macros_2_0()).or_insert(
@ -998,23 +1006,26 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
| Res::Err => bug!("unexpected resolution: {:?}", res), | Res::Err => bug!("unexpected resolution: {:?}", res),
} }
// Record some extra data for better diagnostics. // Record some extra data for better diagnostics.
let cstore = self.r.cstore();
match res { match res {
Res::Def(DefKind::Struct, def_id) => { Res::Def(DefKind::Struct, def_id) => {
let cstore = self.r.cstore();
if let Some((ctor_kind, ctor_def_id)) = cstore.ctor_untracked(def_id) { if let Some((ctor_kind, ctor_def_id)) = cstore.ctor_untracked(def_id) {
let ctor_res = Res::Def(DefKind::Ctor(CtorOf::Struct, ctor_kind), ctor_def_id); let ctor_res = Res::Def(DefKind::Ctor(CtorOf::Struct, ctor_kind), ctor_def_id);
let ctor_vis = cstore.visibility_untracked(ctor_def_id); let ctor_vis = cstore.visibility_untracked(ctor_def_id);
let field_visibilities = let field_visibilities =
cstore.struct_field_visibilities_untracked(def_id).collect(); cstore.struct_field_visibilities_untracked(def_id).collect();
drop(cstore);
self.r self.r
.struct_constructors .struct_constructors
.insert(def_id, (ctor_res, ctor_vis, field_visibilities)); .insert(def_id, (ctor_res, ctor_vis, field_visibilities));
} else {
drop(cstore);
} }
self.insert_field_names_extern(def_id) self.insert_field_names_extern(def_id)
} }
Res::Def(DefKind::Union, def_id) => self.insert_field_names_extern(def_id), Res::Def(DefKind::Union, def_id) => self.insert_field_names_extern(def_id),
Res::Def(DefKind::AssocFn, def_id) => { Res::Def(DefKind::AssocFn, def_id) => {
if cstore.fn_has_self_parameter_untracked(def_id, self.r.session) { if self.r.cstore().fn_has_self_parameter_untracked(def_id, self.r.tcx.sess) {
self.r.has_self.insert(def_id); self.r.has_self.insert(def_id);
} }
} }
@ -1033,7 +1044,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
let msg = format!("`{}` is already in scope", name); let msg = format!("`{}` is already in scope", name);
let note = let note =
"macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)"; "macro-expanded `#[macro_use]`s may not shadow existing macros (see RFC 1560)";
self.r.session.struct_span_err(span, &msg).note(note).emit(); self.r.tcx.sess.struct_span_err(span, &msg).note(note).emit();
} }
} }
@ -1045,7 +1056,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
if attr.has_name(sym::macro_use) { if attr.has_name(sym::macro_use) {
if self.parent_scope.module.parent.is_some() { if self.parent_scope.module.parent.is_some() {
struct_span_err!( struct_span_err!(
self.r.session, self.r.tcx.sess,
item.span, item.span,
E0468, E0468,
"an `extern crate` loading macros must be at the crate root" "an `extern crate` loading macros must be at the crate root"
@ -1055,7 +1066,8 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
if let ItemKind::ExternCrate(Some(orig_name)) = item.kind { if let ItemKind::ExternCrate(Some(orig_name)) = item.kind {
if orig_name == kw::SelfLower { if orig_name == kw::SelfLower {
self.r self.r
.session .tcx
.sess
.struct_span_err( .struct_span_err(
attr.span, attr.span,
"`#[macro_use]` is not supported on `extern crate self`", "`#[macro_use]` is not supported on `extern crate self`",
@ -1064,7 +1076,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
} }
} }
let ill_formed = |span| { let ill_formed = |span| {
struct_span_err!(self.r.session, span, E0466, "bad macro import").emit(); struct_span_err!(self.r.tcx.sess, span, E0466, "bad macro import").emit();
}; };
match attr.meta() { match attr.meta() {
Some(meta) => match meta.kind { Some(meta) => match meta.kind {
@ -1135,8 +1147,13 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
allow_shadowing, allow_shadowing,
); );
} else { } else {
struct_span_err!(self.r.session, ident.span, E0469, "imported macro not found") struct_span_err!(
.emit(); self.r.tcx.sess,
ident.span,
E0469,
"imported macro not found"
)
.emit();
} }
} }
} }
@ -1148,7 +1165,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
for attr in attrs { for attr in attrs {
if attr.has_name(sym::macro_escape) { if attr.has_name(sym::macro_escape) {
let msg = "`#[macro_escape]` is a deprecated synonym for `#[macro_use]`"; let msg = "`#[macro_escape]` is a deprecated synonym for `#[macro_use]`";
let mut err = self.r.session.struct_span_warn(attr.span, msg); let mut err = self.r.tcx.sess.struct_span_warn(attr.span, msg);
if let ast::AttrStyle::Inner = attr.style { if let ast::AttrStyle::Inner = attr.style {
err.help("try an outer attribute: `#[macro_use]`").emit(); err.help("try an outer attribute: `#[macro_use]`").emit();
} else { } else {
@ -1159,7 +1176,10 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
} }
if !attr.is_word() { if !attr.is_word() {
self.r.session.span_err(attr.span, "arguments to `macro_use` are not allowed here"); self.r
.tcx
.sess
.span_err(attr.span, "arguments to `macro_use` are not allowed here");
} }
return true; return true;
} }
@ -1183,11 +1203,11 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
} }
fn proc_macro_stub(&self, item: &ast::Item) -> Option<(MacroKind, Ident, Span)> { fn proc_macro_stub(&self, item: &ast::Item) -> Option<(MacroKind, Ident, Span)> {
if self.r.session.contains_name(&item.attrs, sym::proc_macro) { if self.r.tcx.sess.contains_name(&item.attrs, sym::proc_macro) {
return Some((MacroKind::Bang, item.ident, item.span)); return Some((MacroKind::Bang, item.ident, item.span));
} else if self.r.session.contains_name(&item.attrs, sym::proc_macro_attribute) { } else if self.r.tcx.sess.contains_name(&item.attrs, sym::proc_macro_attribute) {
return Some((MacroKind::Attr, item.ident, item.span)); return Some((MacroKind::Attr, item.ident, item.span));
} else if let Some(attr) = self.r.session.find_by_name(&item.attrs, sym::proc_macro_derive) } else if let Some(attr) = self.r.tcx.sess.find_by_name(&item.attrs, sym::proc_macro_derive)
{ {
if let Some(nested_meta) = attr.meta_item_list().and_then(|list| list.get(0).cloned()) { if let Some(nested_meta) = attr.meta_item_list().and_then(|list| list.get(0).cloned()) {
if let Some(ident) = nested_meta.ident() { if let Some(ident) = nested_meta.ident() {
@ -1222,7 +1242,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
let def_id = self.r.local_def_id(item.id); let def_id = self.r.local_def_id(item.id);
let (ext, ident, span, macro_rules, rule_spans) = match &item.kind { let (ext, ident, span, macro_rules, rule_spans) = match &item.kind {
ItemKind::MacroDef(def) => { ItemKind::MacroDef(def) => {
let (ext, rule_spans) = self.r.compile_macro(item, self.r.session.edition()); let (ext, rule_spans) = self.r.compile_macro(item, self.r.tcx.sess.edition());
let ext = Lrc::new(ext); let ext = Lrc::new(ext);
(ext, item.ident, item.span, def.macro_rules, rule_spans) (ext, item.ident, item.span, def.macro_rules, rule_spans)
} }
@ -1243,7 +1263,7 @@ impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
if macro_rules { if macro_rules {
let ident = ident.normalize_to_macros_2_0(); let ident = ident.normalize_to_macros_2_0();
self.r.macro_names.insert(ident); self.r.macro_names.insert(ident);
let is_macro_export = self.r.session.contains_name(&item.attrs, sym::macro_export); let is_macro_export = self.r.tcx.sess.contains_name(&item.attrs, sym::macro_export);
let vis = if is_macro_export { let vis = if is_macro_export {
ty::Visibility::Public ty::Visibility::Public
} else { } else {
@ -1507,7 +1527,7 @@ impl<'a, 'b, 'tcx> Visitor<'b> for BuildReducedGraphVisitor<'a, 'b, 'tcx> {
// If the variant is marked as non_exhaustive then lower the visibility to within the crate. // If the variant is marked as non_exhaustive then lower the visibility to within the crate.
let ctor_vis = if vis.is_public() let ctor_vis = if vis.is_public()
&& self.r.session.contains_name(&variant.attrs, sym::non_exhaustive) && self.r.tcx.sess.contains_name(&variant.attrs, sym::non_exhaustive)
{ {
ty::Visibility::Restricted(CRATE_DEF_ID) ty::Visibility::Restricted(CRATE_DEF_ID)
} else { } else {

4
compiler/rustc_resolve/src/check_unused.rs
View file

@ -290,7 +290,7 @@ impl Resolver<'_, '_> {
let ms = MultiSpan::from_spans(spans.clone()); let ms = MultiSpan::from_spans(spans.clone());
let mut span_snippets = spans let mut span_snippets = spans
.iter() .iter()
.filter_map(|s| match visitor.r.session.source_map().span_to_snippet(*s) { .filter_map(|s| match visitor.r.tcx.sess.source_map().span_to_snippet(*s) {
Ok(s) => Some(format!("`{}`", s)), Ok(s) => Some(format!("`{}`", s)),
_ => None, _ => None,
}) })
@ -317,7 +317,7 @@ impl Resolver<'_, '_> {
// If we are in the `--test` mode, suppress a help that adds the `#[cfg(test)]` // If we are in the `--test` mode, suppress a help that adds the `#[cfg(test)]`
// attribute; however, if not, suggest adding the attribute. There is no way to // attribute; however, if not, suggest adding the attribute. There is no way to
// retrieve attributes here because we do not have a `TyCtxt` yet. // retrieve attributes here because we do not have a `TyCtxt` yet.
let test_module_span = if visitor.r.session.opts.test { let test_module_span = if visitor.r.tcx.sess.opts.test {
None None
} else { } else {
let parent_module = visitor.r.get_nearest_non_block_module( let parent_module = visitor.r.get_nearest_non_block_module(

151
compiler/rustc_resolve/src/diagnostics.rs
View file

@ -154,8 +154,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if !candidates.is_empty() { if !candidates.is_empty() {
show_candidates( show_candidates(
&self.session, &self.tcx.sess,
&self.untracked.source_span, &self.tcx.untracked().source_span.read(),
&mut err, &mut err,
span, span,
&candidates, &candidates,
@ -206,7 +206,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}; };
let (name, span) = let (name, span) =
(ident.name, self.session.source_map().guess_head_span(new_binding.span)); (ident.name, self.tcx.sess.source_map().guess_head_span(new_binding.span));
if let Some(s) = self.name_already_seen.get(&name) { if let Some(s) = self.name_already_seen.get(&name) {
if s == &span { if s == &span {
@ -226,15 +226,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let msg = format!("the name `{}` is defined multiple times", name); let msg = format!("the name `{}` is defined multiple times", name);
let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) { let mut err = match (old_binding.is_extern_crate(), new_binding.is_extern_crate()) {
(true, true) => struct_span_err!(self.session, span, E0259, "{}", msg), (true, true) => struct_span_err!(self.tcx.sess, span, E0259, "{}", msg),
(true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() { (true, _) | (_, true) => match new_binding.is_import() && old_binding.is_import() {
true => struct_span_err!(self.session, span, E0254, "{}", msg), true => struct_span_err!(self.tcx.sess, span, E0254, "{}", msg),
false => struct_span_err!(self.session, span, E0260, "{}", msg), false => struct_span_err!(self.tcx.sess, span, E0260, "{}", msg),
}, },
_ => match (old_binding.is_import_user_facing(), new_binding.is_import_user_facing()) { _ => match (old_binding.is_import_user_facing(), new_binding.is_import_user_facing()) {
(false, false) => struct_span_err!(self.session, span, E0428, "{}", msg), (false, false) => struct_span_err!(self.tcx.sess, span, E0428, "{}", msg),
(true, true) => struct_span_err!(self.session, span, E0252, "{}", msg), (true, true) => struct_span_err!(self.tcx.sess, span, E0252, "{}", msg),
_ => struct_span_err!(self.session, span, E0255, "{}", msg), _ => struct_span_err!(self.tcx.sess, span, E0255, "{}", msg),
}, },
}; };
@ -248,7 +248,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err.span_label(span, format!("`{}` re{} here", name, new_participle)); err.span_label(span, format!("`{}` re{} here", name, new_participle));
if !old_binding.span.is_dummy() && old_binding.span != span { if !old_binding.span.is_dummy() && old_binding.span != span {
err.span_label( err.span_label(
self.session.source_map().guess_head_span(old_binding.span), self.tcx.sess.source_map().guess_head_span(old_binding.span),
format!("previous {} of the {} `{}` here", old_noun, old_kind, name), format!("previous {} of the {} `{}` here", old_noun, old_kind, name),
); );
} }
@ -352,7 +352,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if let Some(pos) = if let Some(pos) =
source.span.hi().0.checked_sub(binding_span.lo().0).map(|pos| pos as usize) source.span.hi().0.checked_sub(binding_span.lo().0).map(|pos| pos as usize)
{ {
if let Ok(snippet) = self.session.source_map().span_to_snippet(binding_span) { if let Ok(snippet) = self.tcx.sess.source_map().span_to_snippet(binding_span) {
if pos <= snippet.len() { if pos <= snippet.len() {
suggestion = Some(format!( suggestion = Some(format!(
"{} as {}{}", "{} as {}{}",
@ -426,12 +426,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// `a` and `import.use_span` is `issue_52891::{d, e, a};`. // `a` and `import.use_span` is `issue_52891::{d, e, a};`.
let (found_closing_brace, span) = let (found_closing_brace, span) =
find_span_of_binding_until_next_binding(self.session, binding_span, import.use_span); find_span_of_binding_until_next_binding(self.tcx.sess, binding_span, import.use_span);
// If there was a closing brace then identify the span to remove any trailing commas from // If there was a closing brace then identify the span to remove any trailing commas from
// previous imports. // previous imports.
if found_closing_brace { if found_closing_brace {
if let Some(span) = extend_span_to_previous_binding(self.session, span) { if let Some(span) = extend_span_to_previous_binding(self.tcx.sess, span) {
err.tool_only_span_suggestion(span, message, "", Applicability::MaybeIncorrect); err.tool_only_span_suggestion(span, message, "", Applicability::MaybeIncorrect);
} else { } else {
// Remove the entire line if we cannot extend the span back, this indicates an // Remove the entire line if we cannot extend the span back, this indicates an
@ -462,7 +462,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let first_name = match path.get(0) { let first_name = match path.get(0) {
// In the 2018 edition this lint is a hard error, so nothing to do // In the 2018 edition this lint is a hard error, so nothing to do
Some(seg) if seg.ident.span.is_rust_2015() && self.session.is_rust_2015() => { Some(seg) if seg.ident.span.is_rust_2015() && self.tcx.sess.is_rust_2015() => {
seg.ident.name seg.ident.name
} }
_ => return, _ => return,
@ -541,14 +541,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
match resolution_error { match resolution_error {
ResolutionError::GenericParamsFromOuterFunction(outer_res, has_generic_params) => { ResolutionError::GenericParamsFromOuterFunction(outer_res, has_generic_params) => {
let mut err = struct_span_err!( let mut err = struct_span_err!(
self.session, self.tcx.sess,
span, span,
E0401, E0401,
"can't use generic parameters from outer function", "can't use generic parameters from outer function",
); );
err.span_label(span, "use of generic parameter from outer function"); err.span_label(span, "use of generic parameter from outer function");
let sm = self.session.source_map(); let sm = self.tcx.sess.source_map();
let def_id = match outer_res { let def_id = match outer_res {
Res::SelfTyParam { .. } => { Res::SelfTyParam { .. } => {
err.span_label(span, "can't use `Self` here"); err.span_label(span, "can't use `Self` here");
@ -605,10 +605,11 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err err
} }
ResolutionError::NameAlreadyUsedInParameterList(name, first_use_span) => self ResolutionError::NameAlreadyUsedInParameterList(name, first_use_span) => self
.session .tcx
.sess
.create_err(errs::NameAlreadyUsedInParameterList { span, first_use_span, name }), .create_err(errs::NameAlreadyUsedInParameterList { span, first_use_span, name }),
ResolutionError::MethodNotMemberOfTrait(method, trait_, candidate) => { ResolutionError::MethodNotMemberOfTrait(method, trait_, candidate) => {
self.session.create_err(errs::MethodNotMemberOfTrait { self.tcx.sess.create_err(errs::MethodNotMemberOfTrait {
span, span,
method, method,
trait_, trait_,
@ -619,7 +620,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}) })
} }
ResolutionError::TypeNotMemberOfTrait(type_, trait_, candidate) => { ResolutionError::TypeNotMemberOfTrait(type_, trait_, candidate) => {
self.session.create_err(errs::TypeNotMemberOfTrait { self.tcx.sess.create_err(errs::TypeNotMemberOfTrait {
span, span,
type_, type_,
trait_, trait_,
@ -630,7 +631,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}) })
} }
ResolutionError::ConstNotMemberOfTrait(const_, trait_, candidate) => { ResolutionError::ConstNotMemberOfTrait(const_, trait_, candidate) => {
self.session.create_err(errs::ConstNotMemberOfTrait { self.tcx.sess.create_err(errs::ConstNotMemberOfTrait {
span, span,
const_, const_,
trait_, trait_,
@ -648,7 +649,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let msp = MultiSpan::from_spans(target_sp.clone()); let msp = MultiSpan::from_spans(target_sp.clone());
let mut err = struct_span_err!( let mut err = struct_span_err!(
self.session, self.tcx.sess,
msp, msp,
E0408, E0408,
"variable `{}` is not bound in all patterns", "variable `{}` is not bound in all patterns",
@ -686,8 +687,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err.span_help(span, &help_msg); err.span_help(span, &help_msg);
} }
show_candidates( show_candidates(
&self.session, &self.tcx.sess,
&self.untracked.source_span, &self.tcx.untracked().source_span.read(),
&mut err, &mut err,
Some(span), Some(span),
&import_suggestions, &import_suggestions,
@ -701,17 +702,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err err
} }
ResolutionError::VariableBoundWithDifferentMode(variable_name, first_binding_span) => { ResolutionError::VariableBoundWithDifferentMode(variable_name, first_binding_span) => {
self.session.create_err(errs::VariableBoundWithDifferentMode { self.tcx.sess.create_err(errs::VariableBoundWithDifferentMode {
span, span,
first_binding_span, first_binding_span,
variable_name, variable_name,
}) })
} }
ResolutionError::IdentifierBoundMoreThanOnceInParameterList(identifier) => self ResolutionError::IdentifierBoundMoreThanOnceInParameterList(identifier) => self
.session .tcx
.sess
.create_err(errs::IdentifierBoundMoreThanOnceInParameterList { span, identifier }), .create_err(errs::IdentifierBoundMoreThanOnceInParameterList { span, identifier }),
ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(identifier) => self ResolutionError::IdentifierBoundMoreThanOnceInSamePattern(identifier) => self
.session .tcx
.sess
.create_err(errs::IdentifierBoundMoreThanOnceInSamePattern { span, identifier }), .create_err(errs::IdentifierBoundMoreThanOnceInSamePattern { span, identifier }),
ResolutionError::UndeclaredLabel { name, suggestion } => { ResolutionError::UndeclaredLabel { name, suggestion } => {
let ((sub_reachable, sub_reachable_suggestion), sub_unreachable) = match suggestion let ((sub_reachable, sub_reachable_suggestion), sub_unreachable) = match suggestion
@ -737,7 +740,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// No similarly-named labels exist. // No similarly-named labels exist.
None => ((None, None), None), None => ((None, None), None),
}; };
self.session.create_err(errs::UndeclaredLabel { self.tcx.sess.create_err(errs::UndeclaredLabel {
span, span,
name, name,
sub_reachable, sub_reachable,
@ -762,21 +765,22 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}; };
(Some(suggestion), Some(mpart_suggestion)) (Some(suggestion), Some(mpart_suggestion))
}; };
self.session.create_err(errs::SelfImportsOnlyAllowedWithin { self.tcx.sess.create_err(errs::SelfImportsOnlyAllowedWithin {
span, span,
suggestion, suggestion,
mpart_suggestion, mpart_suggestion,
}) })
} }
ResolutionError::SelfImportCanOnlyAppearOnceInTheList => { ResolutionError::SelfImportCanOnlyAppearOnceInTheList => {
self.session.create_err(errs::SelfImportCanOnlyAppearOnceInTheList { span }) self.tcx.sess.create_err(errs::SelfImportCanOnlyAppearOnceInTheList { span })
}
ResolutionError::SelfImportOnlyInImportListWithNonEmptyPrefix => {
self.session.create_err(errs::SelfImportOnlyInImportListWithNonEmptyPrefix { span })
} }
ResolutionError::SelfImportOnlyInImportListWithNonEmptyPrefix => self
.tcx
.sess
.create_err(errs::SelfImportOnlyInImportListWithNonEmptyPrefix { span }),
ResolutionError::FailedToResolve { label, suggestion } => { ResolutionError::FailedToResolve { label, suggestion } => {
let mut err = let mut err =
struct_span_err!(self.session, span, E0433, "failed to resolve: {}", &label); struct_span_err!(self.tcx.sess, span, E0433, "failed to resolve: {}", &label);
err.span_label(span, label); err.span_label(span, label);
if let Some((suggestions, msg, applicability)) = suggestion { if let Some((suggestions, msg, applicability)) = suggestion {
@ -790,7 +794,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err err
} }
ResolutionError::CannotCaptureDynamicEnvironmentInFnItem => { ResolutionError::CannotCaptureDynamicEnvironmentInFnItem => {
self.session.create_err(errs::CannotCaptureDynamicEnvironmentInFnItem { span }) self.tcx.sess.create_err(errs::CannotCaptureDynamicEnvironmentInFnItem { span })
} }
ResolutionError::AttemptToUseNonConstantValueInConstant(ident, suggestion, current) => { ResolutionError::AttemptToUseNonConstantValueInConstant(ident, suggestion, current) => {
// let foo =... // let foo =...
@ -802,12 +806,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// the further the two are apart, the higher the chance of the suggestion being wrong // the further the two are apart, the higher the chance of the suggestion being wrong
let sp = self let sp = self
.session .tcx
.sess
.source_map() .source_map()
.span_extend_to_prev_str(ident.span, current, true, false); .span_extend_to_prev_str(ident.span, current, true, false);
let ((with, with_label), without) = match sp { let ((with, with_label), without) = match sp {
Some(sp) if !self.session.source_map().is_multiline(sp) => { Some(sp) if !self.tcx.sess.source_map().is_multiline(sp) => {
let sp = sp.with_lo(BytePos(sp.lo().0 - (current.len() as u32))); let sp = sp.with_lo(BytePos(sp.lo().0 - (current.len() as u32)));
( (
(Some(errs::AttemptToUseNonConstantValueInConstantWithSuggestion { (Some(errs::AttemptToUseNonConstantValueInConstantWithSuggestion {
@ -828,7 +833,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
), ),
}; };
self.session.create_err(errs::AttemptToUseNonConstantValueInConstant { self.tcx.sess.create_err(errs::AttemptToUseNonConstantValueInConstant {
span, span,
with, with,
with_label, with_label,
@ -842,7 +847,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
article, article,
shadowed_binding, shadowed_binding,
shadowed_binding_span, shadowed_binding_span,
} => self.session.create_err(errs::BindingShadowsSomethingUnacceptable { } => self.tcx.sess.create_err(errs::BindingShadowsSomethingUnacceptable {
span, span,
shadowing_binding, shadowing_binding,
shadowed_binding, shadowed_binding,
@ -859,13 +864,13 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
name, name,
}), }),
ResolutionError::ForwardDeclaredGenericParam => { ResolutionError::ForwardDeclaredGenericParam => {
self.session.create_err(errs::ForwardDeclaredGenericParam { span }) self.tcx.sess.create_err(errs::ForwardDeclaredGenericParam { span })
} }
ResolutionError::ParamInTyOfConstParam(name) => { ResolutionError::ParamInTyOfConstParam(name) => {
self.session.create_err(errs::ParamInTyOfConstParam { span, name }) self.tcx.sess.create_err(errs::ParamInTyOfConstParam { span, name })
} }
ResolutionError::ParamInNonTrivialAnonConst { name, is_type } => { ResolutionError::ParamInNonTrivialAnonConst { name, is_type } => {
self.session.create_err(errs::ParamInNonTrivialAnonConst { self.tcx.sess.create_err(errs::ParamInNonTrivialAnonConst {
span, span,
name, name,
sub_is_type: if is_type { sub_is_type: if is_type {
@ -874,13 +879,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
errs::ParamInNonTrivialAnonConstIsType::NotAType { name } errs::ParamInNonTrivialAnonConstIsType::NotAType { name }
}, },
help: self help: self
.session .tcx
.sess
.is_nightly_build() .is_nightly_build()
.then_some(errs::ParamInNonTrivialAnonConstHelp), .then_some(errs::ParamInNonTrivialAnonConstHelp),
}) })
} }
ResolutionError::SelfInGenericParamDefault => { ResolutionError::SelfInGenericParamDefault => {
self.session.create_err(errs::SelfInGenericParamDefault { span }) self.tcx.sess.create_err(errs::SelfInGenericParamDefault { span })
} }
ResolutionError::UnreachableLabel { name, definition_span, suggestion } => { ResolutionError::UnreachableLabel { name, definition_span, suggestion } => {
let ((sub_suggestion_label, sub_suggestion), sub_unreachable_label) = let ((sub_suggestion_label, sub_suggestion), sub_unreachable_label) =
@ -908,7 +914,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// No similarly-named labels exist. // No similarly-named labels exist.
None => ((None, None), None), None => ((None, None), None),
}; };
self.session.create_err(errs::UnreachableLabel { self.tcx.sess.create_err(errs::UnreachableLabel {
span, span,
name, name,
definition_span, definition_span,
@ -924,7 +930,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
trait_item_span, trait_item_span,
trait_path, trait_path,
} => { } => {
let mut err = self.session.struct_span_err_with_code( let mut err = self.tcx.sess.struct_span_err_with_code(
span, span,
&format!( &format!(
"item `{}` is an associated {}, which doesn't match its trait `{}`", "item `{}` is an associated {}, which doesn't match its trait `{}`",
@ -937,9 +943,12 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
err err
} }
ResolutionError::TraitImplDuplicate { name, trait_item_span, old_span } => self ResolutionError::TraitImplDuplicate { name, trait_item_span, old_span } => self
.session .tcx
.sess
.create_err(errs::TraitImplDuplicate { span, name, trait_item_span, old_span }), .create_err(errs::TraitImplDuplicate { span, name, trait_item_span, old_span }),
ResolutionError::InvalidAsmSym => self.session.create_err(errs::InvalidAsmSym { span }), ResolutionError::InvalidAsmSym => {
self.tcx.sess.create_err(errs::InvalidAsmSym { span })
}
} }
} }
@ -949,7 +958,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
) -> ErrorGuaranteed { ) -> ErrorGuaranteed {
match vis_resolution_error { match vis_resolution_error {
VisResolutionError::Relative2018(span, path) => { VisResolutionError::Relative2018(span, path) => {
self.session.create_err(errs::Relative2018 { self.tcx.sess.create_err(errs::Relative2018 {
span, span,
path_span: path.span, path_span: path.span,
// intentionally converting to String, as the text would also be used as // intentionally converting to String, as the text would also be used as
@ -958,18 +967,20 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}) })
} }
VisResolutionError::AncestorOnly(span) => { VisResolutionError::AncestorOnly(span) => {
self.session.create_err(errs::AncestorOnly(span)) self.tcx.sess.create_err(errs::AncestorOnly(span))
} }
VisResolutionError::FailedToResolve(span, label, suggestion) => { VisResolutionError::FailedToResolve(span, label, suggestion) => {
self.into_struct_error(span, ResolutionError::FailedToResolve { label, suggestion }) self.into_struct_error(span, ResolutionError::FailedToResolve { label, suggestion })
} }
VisResolutionError::ExpectedFound(span, path_str, res) => { VisResolutionError::ExpectedFound(span, path_str, res) => {
self.session.create_err(errs::ExpectedFound { span, res, path_str }) self.tcx.sess.create_err(errs::ExpectedFound { span, res, path_str })
} }
VisResolutionError::Indeterminate(span) => { VisResolutionError::Indeterminate(span) => {
self.session.create_err(errs::Indeterminate(span)) self.tcx.sess.create_err(errs::Indeterminate(span))
}
VisResolutionError::ModuleOnly(span) => {
self.tcx.sess.create_err(errs::ModuleOnly(span))
} }
VisResolutionError::ModuleOnly(span) => self.session.create_err(errs::ModuleOnly(span)),
} }
.emit() .emit()
} }
@ -1206,7 +1217,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// a note about editions // a note about editions
let note = if let Some(did) = did { let note = if let Some(did) = did {
let requires_note = !did.is_local() let requires_note = !did.is_local()
&& this.cstore().item_attrs_untracked(did, this.session).any( && this.cstore().item_attrs_untracked(did, this.tcx.sess).any(
|attr| { |attr| {
if attr.has_name(sym::rustc_diagnostic_item) { if attr.has_name(sym::rustc_diagnostic_item) {
[sym::TryInto, sym::TryFrom, sym::FromIterator] [sym::TryInto, sym::TryFrom, sym::FromIterator]
@ -1304,7 +1315,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// otherwise cause duplicate suggestions. // otherwise cause duplicate suggestions.
continue; continue;
} }
let crate_id = self.crate_loader().maybe_process_path_extern(ident.name); let crate_id = self.crate_loader(|c| c.maybe_process_path_extern(ident.name));
if let Some(crate_id) = crate_id { if let Some(crate_id) = crate_id {
let crate_root = self.expect_module(crate_id.as_def_id()); let crate_root = self.expect_module(crate_id.as_def_id());
suggestions.extend(self.lookup_import_candidates_from_module( suggestions.extend(self.lookup_import_candidates_from_module(
@ -1341,8 +1352,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let import_suggestions = let import_suggestions =
self.lookup_import_candidates(ident, Namespace::MacroNS, parent_scope, is_expected); self.lookup_import_candidates(ident, Namespace::MacroNS, parent_scope, is_expected);
show_candidates( show_candidates(
&self.session, &self.tcx.sess,
&self.untracked.source_span, &self.tcx.untracked().source_span.read(),
err, err,
None, None,
&import_suggestions, &import_suggestions,
@ -1366,7 +1377,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
&& let ModuleKind::Def(DefKind::Enum, def_id, _) = parent_scope.module.kind && let ModuleKind::Def(DefKind::Enum, def_id, _) = parent_scope.module.kind
&& let Some(span) = self.opt_span(def_id) && let Some(span) = self.opt_span(def_id)
{ {
let source_map = self.session.source_map(); let source_map = self.tcx.sess.source_map();
let head_span = source_map.guess_head_span(span); let head_span = source_map.guess_head_span(span);
if let Ok(head) = source_map.span_to_snippet(head_span) { if let Ok(head) = source_map.span_to_snippet(head_span) {
err.span_suggestion(head_span, "consider adding a derive", format!("#[derive(Default)]\n{head}"), Applicability::MaybeIncorrect); err.span_suggestion(head_span, "consider adding a derive", format!("#[derive(Default)]\n{head}"), Applicability::MaybeIncorrect);
@ -1443,7 +1454,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}; };
let def_span = suggestion.res.opt_def_id().and_then(|def_id| match def_id.krate { let def_span = suggestion.res.opt_def_id().and_then(|def_id| match def_id.krate {
LOCAL_CRATE => self.opt_span(def_id), LOCAL_CRATE => self.opt_span(def_id),
_ => Some(self.cstore().get_span_untracked(def_id, self.session)), _ => Some(self.cstore().get_span_untracked(def_id, self.tcx.sess)),
}); });
if let Some(def_span) = def_span { if let Some(def_span) = def_span {
if span.overlaps(def_span) { if span.overlaps(def_span) {
@ -1473,7 +1484,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
}; };
err.span_label( err.span_label(
self.session.source_map().guess_head_span(def_span), self.tcx.sess.source_map().guess_head_span(def_span),
&format!( &format!(
"{}{} `{}` defined here", "{}{} `{}` defined here",
prefix, prefix,
@ -1498,7 +1509,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
fn binding_description(&self, b: &NameBinding<'_>, ident: Ident, from_prelude: bool) -> String { fn binding_description(&self, b: &NameBinding<'_>, ident: Ident, from_prelude: bool) -> String {
let res = b.res(); let res = b.res();
if b.span.is_dummy() || !self.session.source_map().is_span_accessible(b.span) { if b.span.is_dummy() || !self.tcx.sess.source_map().is_span_accessible(b.span) {
// These already contain the "built-in" prefix or look bad with it. // These already contain the "built-in" prefix or look bad with it.
let add_built_in = let add_built_in =
!matches!(b.res(), Res::NonMacroAttr(..) | Res::PrimTy(..) | Res::ToolMod); !matches!(b.res(), Res::NonMacroAttr(..) | Res::PrimTy(..) | Res::ToolMod);
@ -1506,7 +1517,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
("", " from prelude") ("", " from prelude")
} else if b.is_extern_crate() } else if b.is_extern_crate()
&& !b.is_import() && !b.is_import()
&& self.session.opts.externs.get(ident.as_str()).is_some() && self.tcx.sess.opts.externs.get(ident.as_str()).is_some()
{ {
("", " passed with `--extern`") ("", " passed with `--extern`")
} else if add_built_in { } else if add_built_in {
@ -1532,7 +1543,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
(b1, b2, misc1, misc2, false) (b1, b2, misc1, misc2, false)
}; };
let mut err = struct_span_err!(self.session, ident.span, E0659, "`{ident}` is ambiguous"); let mut err = struct_span_err!(self.tcx.sess, ident.span, E0659, "`{ident}` is ambiguous");
err.span_label(ident.span, "ambiguous name"); err.span_label(ident.span, "ambiguous name");
err.note(&format!("ambiguous because of {}", kind.descr())); err.note(&format!("ambiguous because of {}", kind.descr()));
@ -1604,7 +1615,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// Print the primary message. // Print the primary message.
let descr = get_descr(binding); let descr = get_descr(binding);
let mut err = let mut err =
struct_span_err!(self.session, ident.span, E0603, "{} `{}` is private", descr, ident); struct_span_err!(self.tcx.sess, ident.span, E0603, "{} `{}` is private", descr, ident);
err.span_label(ident.span, &format!("private {}", descr)); err.span_label(ident.span, &format!("private {}", descr));
if let Some(span) = ctor_fields_span { if let Some(span) = ctor_fields_span {
err.span_label(span, "a constructor is private if any of the fields is private"); err.span_label(span, "a constructor is private if any of the fields is private");
@ -1650,7 +1661,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
which = if first { "" } else { " which" }, which = if first { "" } else { " which" },
dots = if next_binding.is_some() { "..." } else { "" }, dots = if next_binding.is_some() { "..." } else { "" },
); );
let def_span = self.session.source_map().guess_head_span(binding.span); let def_span = self.tcx.sess.source_map().guess_head_span(binding.span);
let mut note_span = MultiSpan::from_span(def_span); let mut note_span = MultiSpan::from_span(def_span);
if !first && binding.vis.is_public() { if !first && binding.vis.is_public() {
note_span.push_span_label(def_span, "consider importing it directly"); note_span.push_span_label(def_span, "consider importing it directly");
@ -1719,7 +1730,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Applicability::MaybeIncorrect, Applicability::MaybeIncorrect,
)), )),
) )
} else if self.session.is_rust_2015() { } else if self.tcx.sess.is_rust_2015() {
( (
format!("maybe a missing crate `{ident}`?"), format!("maybe a missing crate `{ident}`?"),
Some(( Some((
@ -1738,7 +1749,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let parent = match parent { let parent = match parent {
// ::foo is mounted at the crate root for 2015, and is the extern // ::foo is mounted at the crate root for 2015, and is the extern
// prelude for 2018+ // prelude for 2018+
kw::PathRoot if self.session.edition() > Edition::Edition2015 => { kw::PathRoot if self.tcx.sess.edition() > Edition::Edition2015 => {
"the list of imported crates".to_owned() "the list of imported crates".to_owned()
} }
kw::PathRoot | kw::Crate => "the crate root".to_owned(), kw::PathRoot | kw::Crate => "the crate root".to_owned(),
@ -2079,7 +2090,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
// ie. `use a::b::{c, d, e};` // ie. `use a::b::{c, d, e};`
// ^^^ // ^^^
let (found_closing_brace, binding_span) = find_span_of_binding_until_next_binding( let (found_closing_brace, binding_span) = find_span_of_binding_until_next_binding(
self.r.session, self.r.tcx.sess,
import.span, import.span,
import.use_span, import.use_span,
); );
@ -2098,7 +2109,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
// ie. `use a::b::{c, d};` // ie. `use a::b::{c, d};`
// ^^^ // ^^^
if let Some(previous_span) = if let Some(previous_span) =
extend_span_to_previous_binding(self.r.session, binding_span) extend_span_to_previous_binding(self.r.tcx.sess, binding_span)
{ {
debug!("check_for_module_export_macro: previous_span={:?}", previous_span); debug!("check_for_module_export_macro: previous_span={:?}", previous_span);
removal_span = removal_span.with_lo(previous_span.lo()); removal_span = removal_span.with_lo(previous_span.lo());
@ -2116,7 +2127,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
// or `use a::{b, c, d}};` // or `use a::{b, c, d}};`
// ^^^^^^^^^^^ // ^^^^^^^^^^^
let (has_nested, after_crate_name) = find_span_immediately_after_crate_name( let (has_nested, after_crate_name) = find_span_immediately_after_crate_name(
self.r.session, self.r.tcx.sess,
module_name, module_name,
import.use_span, import.use_span,
); );
@ -2125,7 +2136,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
has_nested, after_crate_name has_nested, after_crate_name
); );
let source_map = self.r.session.source_map(); let source_map = self.r.tcx.sess.source_map();
// Make sure this is actually crate-relative. // Make sure this is actually crate-relative.
let is_definitely_crate = import let is_definitely_crate = import

27
compiler/rustc_resolve/src/effective_visibilities.rs
View file

@ -1,4 +1,4 @@
use crate::{NameBinding, NameBindingKind, Resolver, ResolverTree}; use crate::{NameBinding, NameBindingKind, Resolver};
use rustc_ast::ast; use rustc_ast::ast;
use rustc_ast::visit; use rustc_ast::visit;
use rustc_ast::visit::Visitor; use rustc_ast::visit::Visitor;
@ -7,8 +7,8 @@ use rustc_ast::EnumDef;
use rustc_data_structures::intern::Interned; use rustc_data_structures::intern::Interned;
use rustc_hir::def_id::LocalDefId; use rustc_hir::def_id::LocalDefId;
use rustc_hir::def_id::CRATE_DEF_ID; use rustc_hir::def_id::CRATE_DEF_ID;
use rustc_middle::middle::privacy::Level;
use rustc_middle::middle::privacy::{EffectiveVisibilities, EffectiveVisibility}; use rustc_middle::middle::privacy::{EffectiveVisibilities, EffectiveVisibility};
use rustc_middle::middle::privacy::{IntoDefIdTree, Level};
use rustc_middle::ty::{DefIdTree, Visibility}; use rustc_middle::ty::{DefIdTree, Visibility};
use std::mem; use std::mem;
@ -67,13 +67,6 @@ impl Resolver<'_, '_> {
} }
} }
impl<'a, 'b, 'tcx> IntoDefIdTree for &'b mut Resolver<'a, 'tcx> {
type Tree = &'b Resolver<'a, 'tcx>;
fn tree(self) -> Self::Tree {
self
}
}
impl<'r, 'a, 'tcx> EffectiveVisibilitiesVisitor<'r, 'a, 'tcx> { impl<'r, 'a, 'tcx> EffectiveVisibilitiesVisitor<'r, 'a, 'tcx> {
/// Fills the `Resolver::effective_visibilities` table with public & exported items /// Fills the `Resolver::effective_visibilities` table with public & exported items
/// For now, this doesn't resolve macros (FIXME) and cannot resolve Impl, as we /// For now, this doesn't resolve macros (FIXME) and cannot resolve Impl, as we
@ -107,11 +100,7 @@ impl<'r, 'a, 'tcx> EffectiveVisibilitiesVisitor<'r, 'a, 'tcx> {
for (binding, eff_vis) in visitor.import_effective_visibilities.iter() { for (binding, eff_vis) in visitor.import_effective_visibilities.iter() {
let NameBindingKind::Import { import, .. } = binding.kind else { unreachable!() }; let NameBindingKind::Import { import, .. } = binding.kind else { unreachable!() };
if let Some(node_id) = import.id() { if let Some(node_id) = import.id() {
r.effective_visibilities.update_eff_vis( r.effective_visibilities.update_eff_vis(r.local_def_id(node_id), eff_vis, r.tcx)
r.local_def_id(node_id),
eff_vis,
ResolverTree(&r.untracked),
)
} }
} }
@ -167,26 +156,28 @@ impl<'r, 'a, 'tcx> EffectiveVisibilitiesVisitor<'r, 'a, 'tcx> {
let nominal_vis = binding.vis.expect_local(); let nominal_vis = binding.vis.expect_local();
let private_vis = self.cheap_private_vis(parent_id); let private_vis = self.cheap_private_vis(parent_id);
let inherited_eff_vis = self.effective_vis_or_private(parent_id); let inherited_eff_vis = self.effective_vis_or_private(parent_id);
let tcx = self.r.tcx;
self.changed |= self.import_effective_visibilities.update( self.changed |= self.import_effective_visibilities.update(
binding, binding,
nominal_vis, nominal_vis,
|r| (private_vis.unwrap_or_else(|| r.private_vis_import(binding)), r), || private_vis.unwrap_or_else(|| self.r.private_vis_import(binding)),
inherited_eff_vis, inherited_eff_vis,
parent_id.level(), parent_id.level(),
&mut *self.r, tcx,
); );
} }
fn update_def(&mut self, def_id: LocalDefId, nominal_vis: Visibility, parent_id: ParentId<'a>) { fn update_def(&mut self, def_id: LocalDefId, nominal_vis: Visibility, parent_id: ParentId<'a>) {
let private_vis = self.cheap_private_vis(parent_id); let private_vis = self.cheap_private_vis(parent_id);
let inherited_eff_vis = self.effective_vis_or_private(parent_id); let inherited_eff_vis = self.effective_vis_or_private(parent_id);
let tcx = self.r.tcx;
self.changed |= self.def_effective_visibilities.update( self.changed |= self.def_effective_visibilities.update(
def_id, def_id,
nominal_vis, nominal_vis,
|r| (private_vis.unwrap_or_else(|| r.private_vis_def(def_id)), r), || private_vis.unwrap_or_else(|| self.r.private_vis_def(def_id)),
inherited_eff_vis, inherited_eff_vis,
parent_id.level(), parent_id.level(),
&mut *self.r, tcx,
); );
} }

15
compiler/rustc_resolve/src/ident.rs
View file

@ -1179,7 +1179,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
ConstantItemRibKind(trivial, _) => { ConstantItemRibKind(trivial, _) => {
let features = self.session.features_untracked(); let features = self.tcx.sess.features_untracked();
// HACK(min_const_generics): We currently only allow `N` or `{ N }`. // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
if !(trivial == ConstantHasGenerics::Yes if !(trivial == ConstantHasGenerics::Yes
|| features.generic_const_exprs) || features.generic_const_exprs)
@ -1208,7 +1208,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
is_type: true, is_type: true,
}, },
); );
self.session.delay_span_bug(span, CG_BUG_STR); self.tcx.sess.delay_span_bug(span, CG_BUG_STR);
} }
return Res::Err; return Res::Err;
@ -1255,7 +1255,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
| ForwardGenericParamBanRibKind => continue, | ForwardGenericParamBanRibKind => continue,
ConstantItemRibKind(trivial, _) => { ConstantItemRibKind(trivial, _) => {
let features = self.session.features_untracked(); let features = self.tcx.sess.features_untracked();
// HACK(min_const_generics): We currently only allow `N` or `{ N }`. // HACK(min_const_generics): We currently only allow `N` or `{ N }`.
if !(trivial == ConstantHasGenerics::Yes if !(trivial == ConstantHasGenerics::Yes
|| features.generic_const_exprs) || features.generic_const_exprs)
@ -1268,7 +1268,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
is_type: false, is_type: false,
}, },
); );
self.session.delay_span_bug(span, CG_BUG_STR); self.tcx.sess.delay_span_bug(span, CG_BUG_STR);
} }
return Res::Err; return Res::Err;
@ -1397,7 +1397,9 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
module = Some(ModuleOrUniformRoot::ExternPrelude); module = Some(ModuleOrUniformRoot::ExternPrelude);
continue; continue;
} }
if name == kw::PathRoot && ident.span.is_rust_2015() && self.session.rust_2018() if name == kw::PathRoot
&& ident.span.is_rust_2015()
&& self.tcx.sess.rust_2018()
{ {
// `::a::b` from 2015 macro on 2018 global edition // `::a::b` from 2015 macro on 2018 global edition
module = Some(ModuleOrUniformRoot::CrateRootAndExternPrelude); module = Some(ModuleOrUniformRoot::CrateRootAndExternPrelude);
@ -1494,7 +1496,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
record_segment_res(self, res); record_segment_res(self, res);
} else if res == Res::ToolMod && i + 1 != path.len() { } else if res == Res::ToolMod && i + 1 != path.len() {
if binding.is_import() { if binding.is_import() {
self.session self.tcx
.sess
.struct_span_err( .struct_span_err(
ident.span, ident.span,
"cannot use a tool module through an import", "cannot use a tool module through an import",

24
compiler/rustc_resolve/src/imports.rs
View file

@ -526,7 +526,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
.collect::<Vec<_>>(); .collect::<Vec<_>>();
let msg = format!("unresolved import{} {}", pluralize!(paths.len()), paths.join(", "),); let msg = format!("unresolved import{} {}", pluralize!(paths.len()), paths.join(", "),);
let mut diag = struct_span_err!(self.r.session, span, E0432, "{}", &msg); let mut diag = struct_span_err!(self.r.tcx.sess, span, E0432, "{}", &msg);
if let Some((_, UnresolvedImportError { note: Some(note), .. })) = errors.iter().last() { if let Some((_, UnresolvedImportError { note: Some(note), .. })) = errors.iter().last() {
diag.note(note); diag.note(note);
@ -548,8 +548,8 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
if let Some(candidates) = &err.candidates { if let Some(candidates) = &err.candidates {
match &import.kind { match &import.kind {
ImportKind::Single { nested: false, source, target, .. } => import_candidates( ImportKind::Single { nested: false, source, target, .. } => import_candidates(
self.r.session, self.r.tcx.sess,
&self.r.untracked.source_span, &self.r.tcx.untracked().source_span.read(),
&mut diag, &mut diag,
Some(err.span), Some(err.span),
&candidates, &candidates,
@ -561,8 +561,8 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
), ),
ImportKind::Single { nested: true, source, target, .. } => { ImportKind::Single { nested: true, source, target, .. } => {
import_candidates( import_candidates(
self.r.session, self.r.tcx.sess,
&self.r.untracked.source_span, &self.r.tcx.untracked().source_span.read(),
&mut diag, &mut diag,
None, None,
&candidates, &candidates,
@ -658,7 +658,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
source_binding @ (Ok(..) | Err(Determined)) => { source_binding @ (Ok(..) | Err(Determined)) => {
if source_binding.is_ok() { if source_binding.is_ok() {
let msg = format!("`{}` is not directly importable", target); let msg = format!("`{}` is not directly importable", target);
struct_span_err!(this.session, import.span, E0253, "{}", &msg) struct_span_err!(this.tcx.sess, import.span, E0253, "{}", &msg)
.span_label(import.span, "cannot be imported directly") .span_label(import.span, "cannot be imported directly")
.emit(); .emit();
} }
@ -706,7 +706,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
} else if self.r.privacy_errors.is_empty() { } else if self.r.privacy_errors.is_empty() {
let msg = "cannot determine resolution for the import"; let msg = "cannot determine resolution for the import";
let msg_note = "import resolution is stuck, try simplifying other imports"; let msg_note = "import resolution is stuck, try simplifying other imports";
self.r.session.struct_span_err(import.span, msg).note(msg_note).emit(); self.r.tcx.sess.struct_span_err(import.span, msg).note(msg_note).emit();
} }
module module
@ -859,7 +859,7 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
let msg = "cannot determine resolution for the import"; let msg = "cannot determine resolution for the import";
let msg_note = let msg_note =
"import resolution is stuck, try simplifying other imports"; "import resolution is stuck, try simplifying other imports";
this.session.struct_span_err(import.span, msg).note(msg_note).emit(); this.tcx.sess.struct_span_err(import.span, msg).note(msg_note).emit();
} }
} }
Err(..) => { Err(..) => {
@ -1035,13 +1035,13 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
format!("re-export of private `{}`", ident) format!("re-export of private `{}`", ident)
}; };
struct_span_err!(self.r.session, import.span, E0365, "{}", error_msg) struct_span_err!(self.r.tcx.sess, import.span, E0365, "{}", error_msg)
.span_label(import.span, label_msg) .span_label(import.span, label_msg)
.note(&format!("consider declaring type or module `{}` with `pub`", ident)) .note(&format!("consider declaring type or module `{}` with `pub`", ident))
.emit(); .emit();
} else { } else {
let mut err = let mut err =
struct_span_err!(self.r.session, import.span, E0364, "{error_msg}"); struct_span_err!(self.r.tcx.sess, import.span, E0364, "{error_msg}");
match binding.kind { match binding.kind {
NameBindingKind::Res(Res::Def(DefKind::Macro(_), def_id)) NameBindingKind::Res(Res::Def(DefKind::Macro(_), def_id))
// exclude decl_macro // exclude decl_macro
@ -1164,12 +1164,12 @@ impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
let ImportKind::Glob { id, is_prelude, .. } = import.kind else { unreachable!() }; let ImportKind::Glob { id, is_prelude, .. } = import.kind else { unreachable!() };
let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else { let ModuleOrUniformRoot::Module(module) = import.imported_module.get().unwrap() else {
self.r.session.span_err(import.span, "cannot glob-import all possible crates"); self.r.tcx.sess.span_err(import.span, "cannot glob-import all possible crates");
return; return;
}; };
if module.is_trait() { if module.is_trait() {
self.r.session.span_err(import.span, "items in traits are not importable"); self.r.tcx.sess.span_err(import.span, "items in traits are not importable");
return; return;
} else if ptr::eq(module, import.parent_scope.module) { } else if ptr::eq(module, import.parent_scope.module) {
return; return;

35
compiler/rustc_resolve/src/late.rs
View file

@ -682,7 +682,7 @@ impl<'a: 'ast, 'ast, 'tcx> Visitor<'ast> for LateResolutionVisitor<'a, '_, 'ast,
// Elided lifetime in reference: we resolve as if there was some lifetime `'_` with // Elided lifetime in reference: we resolve as if there was some lifetime `'_` with
// NodeId `ty.id`. // NodeId `ty.id`.
// This span will be used in case of elision failure. // This span will be used in case of elision failure.
let span = self.r.session.source_map().start_point(ty.span); let span = self.r.tcx.sess.source_map().start_point(ty.span);
self.resolve_elided_lifetime(ty.id, span); self.resolve_elided_lifetime(ty.id, span);
visit::walk_ty(self, ty); visit::walk_ty(self, ty);
} }
@ -1571,7 +1571,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
("`'_` cannot be used here", "`'_` is a reserved lifetime name") ("`'_` cannot be used here", "`'_` is a reserved lifetime name")
}; };
let mut diag = rustc_errors::struct_span_err!( let mut diag = rustc_errors::struct_span_err!(
self.r.session, self.r.tcx.sess,
lifetime.ident.span, lifetime.ident.span,
E0637, E0637,
"{}", "{}",
@ -1748,7 +1748,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
// impl Foo for std::cell::Ref<u32> // note lack of '_ // impl Foo for std::cell::Ref<u32> // note lack of '_
// async fn foo(_: std::cell::Ref<u32>) { ... } // async fn foo(_: std::cell::Ref<u32>) { ... }
LifetimeRibKind::AnonymousCreateParameter { report_in_path: true, .. } => { LifetimeRibKind::AnonymousCreateParameter { report_in_path: true, .. } => {
let sess = self.r.session; let sess = self.r.tcx.sess;
let mut err = rustc_errors::struct_span_err!( let mut err = rustc_errors::struct_span_err!(
sess, sess,
path_span, path_span,
@ -2194,7 +2194,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
let what = if ns == TypeNS { "type parameters" } else { "local variables" }; let what = if ns == TypeNS { "type parameters" } else { "local variables" };
if this.should_report_errs() { if this.should_report_errs() {
this.r this.r
.session .tcx
.sess
.span_err(ident.span, &format!("imports cannot refer to {}", what)); .span_err(ident.span, &format!("imports cannot refer to {}", what));
} }
}; };
@ -2438,7 +2439,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
if let GenericParamKind::Lifetime = param.kind if let GenericParamKind::Lifetime = param.kind
&& let Some(&original) = seen_lifetimes.get(&ident) && let Some(&original) = seen_lifetimes.get(&ident)
{ {
diagnostics::signal_lifetime_shadowing(self.r.session, original, param.ident); diagnostics::signal_lifetime_shadowing(self.r.tcx.sess, original, param.ident);
// Record lifetime res, so lowering knows there is something fishy. // Record lifetime res, so lowering knows there is something fishy.
self.record_lifetime_param(param.id, LifetimeRes::Error); self.record_lifetime_param(param.id, LifetimeRes::Error);
continue; continue;
@ -2462,7 +2463,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
if param.ident.name == kw::UnderscoreLifetime { if param.ident.name == kw::UnderscoreLifetime {
rustc_errors::struct_span_err!( rustc_errors::struct_span_err!(
self.r.session, self.r.tcx.sess,
param.ident.span, param.ident.span,
E0637, E0637,
"`'_` cannot be used here" "`'_` cannot be used here"
@ -2476,7 +2477,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
if param.ident.name == kw::StaticLifetime { if param.ident.name == kw::StaticLifetime {
rustc_errors::struct_span_err!( rustc_errors::struct_span_err!(
self.r.session, self.r.tcx.sess,
param.ident.span, param.ident.span,
E0262, E0262,
"invalid lifetime parameter name: `{}`", "invalid lifetime parameter name: `{}`",
@ -2506,7 +2507,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
let res = match kind { let res = match kind {
ItemRibKind(..) | AssocItemRibKind => Res::Def(def_kind, def_id.to_def_id()), ItemRibKind(..) | AssocItemRibKind => Res::Def(def_kind, def_id.to_def_id()),
NormalRibKind => { NormalRibKind => {
if self.r.session.features_untracked().non_lifetime_binders { if self.r.tcx.sess.features_untracked().non_lifetime_binders {
Res::Def(def_kind, def_id.to_def_id()) Res::Def(def_kind, def_id.to_def_id())
} else { } else {
Res::Err Res::Err
@ -3384,7 +3385,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
Res::SelfCtor(_) => { Res::SelfCtor(_) => {
// We resolve `Self` in pattern position as an ident sometimes during recovery, // We resolve `Self` in pattern position as an ident sometimes during recovery,
// so delay a bug instead of ICEing. // so delay a bug instead of ICEing.
self.r.session.delay_span_bug( self.r.tcx.sess.delay_span_bug(
ident.span, ident.span,
"unexpected `SelfCtor` in pattern, expected identifier" "unexpected `SelfCtor` in pattern, expected identifier"
); );
@ -3664,7 +3665,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
#[inline] #[inline]
/// If we're actually rustdoc then avoid giving a name resolution error for `cfg()` items. /// If we're actually rustdoc then avoid giving a name resolution error for `cfg()` items.
fn should_report_errs(&self) -> bool { fn should_report_errs(&self) -> bool {
!(self.r.session.opts.actually_rustdoc && self.in_func_body) !(self.r.tcx.sess.opts.actually_rustdoc && self.in_func_body)
} }
// Resolve in alternative namespaces if resolution in the primary namespace fails. // Resolve in alternative namespaces if resolution in the primary namespace fails.
@ -3829,7 +3830,7 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
if let Ok((_, orig_span)) = self.resolve_label(label.ident) { if let Ok((_, orig_span)) = self.resolve_label(label.ident) {
diagnostics::signal_label_shadowing(self.r.session, orig_span, label.ident) diagnostics::signal_label_shadowing(self.r.tcx.sess, orig_span, label.ident)
} }
self.with_label_rib(NormalRibKind, |this| { self.with_label_rib(NormalRibKind, |this| {
@ -4211,8 +4212,8 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
if let Some(res) = res if let Some(res) = res
&& let Some(def_id) = res.opt_def_id() && let Some(def_id) = res.opt_def_id()
&& !def_id.is_local() && !def_id.is_local()
&& self.r.session.crate_types().contains(&CrateType::ProcMacro) && self.r.tcx.sess.crate_types().contains(&CrateType::ProcMacro)
&& matches!(self.r.session.opts.resolve_doc_links, ResolveDocLinks::ExportedMetadata) { && matches!(self.r.tcx.sess.opts.resolve_doc_links, ResolveDocLinks::ExportedMetadata) {
// Encoding foreign def ids in proc macro crate metadata will ICE. // Encoding foreign def ids in proc macro crate metadata will ICE.
return None; return None;
} }
@ -4224,10 +4225,10 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
} }
fn resolve_doc_links(&mut self, attrs: &[Attribute], maybe_exported: MaybeExported<'_>) { fn resolve_doc_links(&mut self, attrs: &[Attribute], maybe_exported: MaybeExported<'_>) {
match self.r.session.opts.resolve_doc_links { match self.r.tcx.sess.opts.resolve_doc_links {
ResolveDocLinks::None => return, ResolveDocLinks::None => return,
ResolveDocLinks::ExportedMetadata ResolveDocLinks::ExportedMetadata
if !self.r.session.crate_types().iter().copied().any(CrateType::has_metadata) if !self.r.tcx.sess.crate_types().iter().copied().any(CrateType::has_metadata)
|| !maybe_exported.eval(self.r) => || !maybe_exported.eval(self.r) =>
{ {
return; return;
@ -4281,9 +4282,9 @@ impl<'a: 'ast, 'b, 'ast, 'tcx> LateResolutionVisitor<'a, 'b, 'ast, 'tcx> {
.into_iter() .into_iter()
.filter_map(|tr| { .filter_map(|tr| {
if !tr.def_id.is_local() if !tr.def_id.is_local()
&& self.r.session.crate_types().contains(&CrateType::ProcMacro) && self.r.tcx.sess.crate_types().contains(&CrateType::ProcMacro)
&& matches!( && matches!(
self.r.session.opts.resolve_doc_links, self.r.tcx.sess.opts.resolve_doc_links,
ResolveDocLinks::ExportedMetadata ResolveDocLinks::ExportedMetadata
) )
{ {

71
compiler/rustc_resolve/src/late/diagnostics.rs
View file

@ -170,7 +170,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
fn def_span(&self, def_id: DefId) -> Option<Span> { fn def_span(&self, def_id: DefId) -> Option<Span> {
match def_id.krate { match def_id.krate {
LOCAL_CRATE => self.r.opt_span(def_id), LOCAL_CRATE => self.r.opt_span(def_id),
_ => Some(self.r.cstore().get_span_untracked(def_id, self.r.session)), _ => Some(self.r.cstore().get_span_untracked(def_id, self.r.tcx.sess)),
} }
} }
@ -200,7 +200,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
Res::Def(DefKind::Fn, _) => { Res::Def(DefKind::Fn, _) => {
// Verify whether this is a fn call or an Fn used as a type. // Verify whether this is a fn call or an Fn used as a type.
self.r self.r
.session .tcx
.sess
.source_map() .source_map()
.span_to_snippet(span) .span_to_snippet(span)
.map(|snippet| snippet.ends_with(')')) .map(|snippet| snippet.ends_with(')'))
@ -255,7 +256,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
}; };
(String::new(), "this scope".to_string(), suggestion) (String::new(), "this scope".to_string(), suggestion)
} else if path.len() == 2 && path[0].ident.name == kw::PathRoot { } else if path.len() == 2 && path[0].ident.name == kw::PathRoot {
if self.r.session.edition() > Edition::Edition2015 { if self.r.tcx.sess.edition() > Edition::Edition2015 {
// In edition 2018 onwards, the `::foo` syntax may only pull from the extern prelude // In edition 2018 onwards, the `::foo` syntax may only pull from the extern prelude
// which overrides all other expectations of item type // which overrides all other expectations of item type
expected = "crate"; expected = "crate";
@ -323,7 +324,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
let base_error = self.make_base_error(path, span, source, res); let base_error = self.make_base_error(path, span, source, res);
let code = source.error_code(res.is_some()); let code = source.error_code(res.is_some());
let mut err = let mut err =
self.r.session.struct_span_err_with_code(base_error.span, &base_error.msg, code); self.r.tcx.sess.struct_span_err_with_code(base_error.span, &base_error.msg, code);
self.suggest_swapping_misplaced_self_ty_and_trait(&mut err, source, res, base_error.span); self.suggest_swapping_misplaced_self_ty_and_trait(&mut err, source, res, base_error.span);
@ -432,7 +433,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
} else { } else {
( (
self.r self.r
.session .tcx
.sess
.source_map() .source_map()
.span_through_char(*fn_span, '(') .span_through_char(*fn_span, '(')
.shrink_to_hi(), .shrink_to_hi(),
@ -505,7 +507,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
{ {
if self if self
.r .r
.session .tcx
.sess
.parse_sess .parse_sess
.type_ascription_path_suggestions .type_ascription_path_suggestions
.borrow() .borrow()
@ -596,7 +599,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
if let Some((call_span, args_span)) = self.call_has_self_arg(source) { if let Some((call_span, args_span)) = self.call_has_self_arg(source) {
let mut args_snippet = String::new(); let mut args_snippet = String::new();
if let Some(args_span) = args_span { if let Some(args_span) = args_span {
if let Ok(snippet) = self.r.session.source_map().span_to_snippet(args_span) { if let Ok(snippet) = self.r.tcx.sess.source_map().span_to_snippet(args_span) {
args_snippet = snippet; args_snippet = snippet;
} }
} }
@ -732,7 +735,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
let ident_span = path.last().map_or(span, |ident| ident.ident.span); let ident_span = path.last().map_or(span, |ident| ident.ident.span);
let typo_sugg = self.lookup_typo_candidate(path, source.namespace(), is_expected); let typo_sugg = self.lookup_typo_candidate(path, source.namespace(), is_expected);
let is_in_same_file = &|sp1, sp2| { let is_in_same_file = &|sp1, sp2| {
let source_map = self.r.session.source_map(); let source_map = self.r.tcx.sess.source_map();
let file1 = source_map.span_to_filename(sp1); let file1 = source_map.span_to_filename(sp1);
let file2 = source_map.span_to_filename(sp2); let file2 = source_map.span_to_filename(sp2);
file1 == file2 file1 == file2
@ -895,7 +898,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
.map_or(*span, |ident| span.with_lo(ident.span.hi())); .map_or(*span, |ident| span.with_lo(ident.span.hi()));
( (
self.r self.r
.session .tcx
.sess
.source_map() .source_map()
.span_through_char(span, '(') .span_through_char(span, '(')
.shrink_to_hi(), .shrink_to_hi(),
@ -949,9 +953,9 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
&& let PathSource::Trait(_) = source && let PathSource::Trait(_) = source
&& let Some(Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, _)) = res && let Some(Res::Def(DefKind::Struct | DefKind::Enum | DefKind::Union, _)) = res
&& let Ok(self_ty_str) = && let Ok(self_ty_str) =
self.r.session.source_map().span_to_snippet(self_ty.span) self.r.tcx.sess.source_map().span_to_snippet(self_ty.span)
&& let Ok(trait_ref_str) = && let Ok(trait_ref_str) =
self.r.session.source_map().span_to_snippet(trait_ref.path.span) self.r.tcx.sess.source_map().span_to_snippet(trait_ref.path.span)
{ {
err.multipart_suggestion( err.multipart_suggestion(
"`impl` items mention the trait being implemented first and the type it is being implemented for second", "`impl` items mention the trait being implemented first and the type it is being implemented for second",
@ -1095,7 +1099,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
format!( format!(
"{}: {}<{} = {}>", "{}: {}<{} = {}>",
self.r self.r
.session .tcx
.sess
.source_map() .source_map()
.span_to_snippet(ty.span) // Account for `<&'a T as Foo>::Bar`. .span_to_snippet(ty.span) // Account for `<&'a T as Foo>::Bar`.
.unwrap_or_else(|_| constrain_ident.to_string()), .unwrap_or_else(|_| constrain_ident.to_string()),
@ -1164,7 +1169,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
// parser issue where a struct literal is being used on an expression // parser issue where a struct literal is being used on an expression
// where a brace being opened means a block is being started. Look // where a brace being opened means a block is being started. Look
// ahead for the next text to see if `span` is followed by a `{`. // ahead for the next text to see if `span` is followed by a `{`.
let sm = self.r.session.source_map(); let sm = self.r.tcx.sess.source_map();
let sp = sm.span_look_ahead(span, None, Some(50)); let sp = sm.span_look_ahead(span, None, Some(50));
let followed_by_brace = matches!(sm.span_to_snippet(sp), Ok(ref snippet) if snippet == "{"); let followed_by_brace = matches!(sm.span_to_snippet(sp), Ok(ref snippet) if snippet == "{");
// In case this could be a struct literal that needs to be surrounded // In case this could be a struct literal that needs to be surrounded
@ -1212,7 +1217,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
true true
} else if kind == DefKind::Struct } else if kind == DefKind::Struct
&& let Some(lhs_source_span) = lhs_span.find_ancestor_inside(expr.span) && let Some(lhs_source_span) = lhs_span.find_ancestor_inside(expr.span)
&& let Ok(snippet) = self.r.session.source_map().span_to_snippet(lhs_source_span) && let Ok(snippet) = self.r.tcx.sess.source_map().span_to_snippet(lhs_source_span)
{ {
// The LHS is a type that originates from a macro call. // The LHS is a type that originates from a macro call.
// We have to add angle brackets around it. // We have to add angle brackets around it.
@ -1352,11 +1357,11 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
} }
(Res::Def(DefKind::TyAlias, def_id), PathSource::Trait(_)) => { (Res::Def(DefKind::TyAlias, def_id), PathSource::Trait(_)) => {
err.span_label(span, "type aliases cannot be used as traits"); err.span_label(span, "type aliases cannot be used as traits");
if self.r.session.is_nightly_build() { if self.r.tcx.sess.is_nightly_build() {
let msg = "you might have meant to use `#![feature(trait_alias)]` instead of a \ let msg = "you might have meant to use `#![feature(trait_alias)]` instead of a \
`type` alias"; `type` alias";
if let Some(span) = self.def_span(def_id) { if let Some(span) = self.def_span(def_id) {
if let Ok(snip) = self.r.session.source_map().span_to_snippet(span) { if let Ok(snip) = self.r.tcx.sess.source_map().span_to_snippet(span) {
// The span contains a type alias so we should be able to // The span contains a type alias so we should be able to
// replace `type` with `trait`. // replace `type` with `trait`.
let snip = snip.replacen("type", "trait", 1); let snip = snip.replacen("type", "trait", 1);
@ -1387,7 +1392,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
.last() .last()
.map(|sp| { .map(|sp| {
self.r self.r
.session .tcx
.sess
.parse_sess .parse_sess
.type_ascription_path_suggestions .type_ascription_path_suggestions
.borrow() .borrow()
@ -1694,8 +1700,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
let extern_prelude = self.r.extern_prelude.clone(); let extern_prelude = self.r.extern_prelude.clone();
names.extend(extern_prelude.iter().flat_map(|(ident, _)| { names.extend(extern_prelude.iter().flat_map(|(ident, _)| {
self.r self.r
.crate_loader() .crate_loader(|c| c.maybe_process_path_extern(ident.name))
.maybe_process_path_extern(ident.name)
.and_then(|crate_id| { .and_then(|crate_id| {
let crate_mod = let crate_mod =
Res::Def(DefKind::Mod, crate_id.as_def_id()); Res::Def(DefKind::Mod, crate_id.as_def_id());
@ -1774,12 +1779,12 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
/// Only used in a specific case of type ascription suggestions /// Only used in a specific case of type ascription suggestions
fn get_colon_suggestion_span(&self, start: Span) -> Span { fn get_colon_suggestion_span(&self, start: Span) -> Span {
let sm = self.r.session.source_map(); let sm = self.r.tcx.sess.source_map();
start.to(sm.next_point(start)) start.to(sm.next_point(start))
} }
fn type_ascription_suggestion(&self, err: &mut Diagnostic, base_span: Span) -> bool { fn type_ascription_suggestion(&self, err: &mut Diagnostic, base_span: Span) -> bool {
let sm = self.r.session.source_map(); let sm = self.r.tcx.sess.source_map();
let base_snippet = sm.span_to_snippet(base_span); let base_snippet = sm.span_to_snippet(base_span);
if let Some(&sp) = self.diagnostic_metadata.current_type_ascription.last() { if let Some(&sp) = self.diagnostic_metadata.current_type_ascription.last() {
if let Ok(snippet) = sm.span_to_snippet(sp) { if let Ok(snippet) = sm.span_to_snippet(sp) {
@ -1809,7 +1814,8 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
show_label = false; show_label = false;
if !self if !self
.r .r
.session .tcx
.sess
.parse_sess .parse_sess
.type_ascription_path_suggestions .type_ascription_path_suggestions
.borrow_mut() .borrow_mut()
@ -2272,7 +2278,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
debug_assert_ne!(lifetime_ref.ident.name, kw::UnderscoreLifetime); debug_assert_ne!(lifetime_ref.ident.name, kw::UnderscoreLifetime);
let mut err = if let Some(outer) = outer_lifetime_ref { let mut err = if let Some(outer) = outer_lifetime_ref {
let mut err = struct_span_err!( let mut err = struct_span_err!(
self.r.session, self.r.tcx.sess,
lifetime_ref.ident.span, lifetime_ref.ident.span,
E0401, E0401,
"can't use generic parameters from outer item", "can't use generic parameters from outer item",
@ -2282,7 +2288,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
err err
} else { } else {
let mut err = struct_span_err!( let mut err = struct_span_err!(
self.r.session, self.r.tcx.sess,
lifetime_ref.ident.span, lifetime_ref.ident.span,
E0261, E0261,
"use of undeclared lifetime name `{}`", "use of undeclared lifetime name `{}`",
@ -2340,8 +2346,13 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
); );
(span, sugg) (span, sugg)
} else { } else {
let span = let span = self
self.r.session.source_map().span_through_char(span, '<').shrink_to_hi(); .r
.tcx
.sess
.source_map()
.span_through_char(span, '<')
.shrink_to_hi();
let sugg = format!("{}, ", name.unwrap_or("'a")); let sugg = format!("{}, ", name.unwrap_or("'a"));
(span, sugg) (span, sugg)
}; };
@ -2375,7 +2386,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
pub(crate) fn emit_non_static_lt_in_const_generic_error(&self, lifetime_ref: &ast::Lifetime) { pub(crate) fn emit_non_static_lt_in_const_generic_error(&self, lifetime_ref: &ast::Lifetime) {
struct_span_err!( struct_span_err!(
self.r.session, self.r.tcx.sess,
lifetime_ref.ident.span, lifetime_ref.ident.span,
E0771, E0771,
"use of non-static lifetime `{}` in const generic", "use of non-static lifetime `{}` in const generic",
@ -2395,10 +2406,10 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
&self, &self,
lifetime_ref: &ast::Lifetime, lifetime_ref: &ast::Lifetime,
) { ) {
let feature_active = self.r.session.features_untracked().generic_const_exprs; let feature_active = self.r.tcx.sess.features_untracked().generic_const_exprs;
if !feature_active { if !feature_active {
feature_err( feature_err(
&self.r.session.parse_sess, &self.r.tcx.sess.parse_sess,
sym::generic_const_exprs, sym::generic_const_exprs,
lifetime_ref.ident.span, lifetime_ref.ident.span,
"a non-static lifetime is not allowed in a `const`", "a non-static lifetime is not allowed in a `const`",
@ -2416,7 +2427,7 @@ impl<'a: 'ast, 'ast, 'tcx> LateResolutionVisitor<'a, '_, 'ast, 'tcx> {
let spans: Vec<_> = lifetime_refs.iter().map(|lt| lt.span).collect(); let spans: Vec<_> = lifetime_refs.iter().map(|lt| lt.span).collect();
let mut err = struct_span_err!( let mut err = struct_span_err!(
self.r.session, self.r.tcx.sess,
spans, spans,
E0106, E0106,
"missing lifetime specifier{}", "missing lifetime specifier{}",

141
compiler/rustc_resolve/src/lib.rs
View file

@ -27,26 +27,25 @@ use rustc_ast::{self as ast, NodeId, CRATE_NODE_ID};
use rustc_ast::{AngleBracketedArg, Crate, Expr, ExprKind, GenericArg, GenericArgs, LitKind, Path}; use rustc_ast::{AngleBracketedArg, Crate, Expr, ExprKind, GenericArg, GenericArgs, LitKind, Path};
use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet}; use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
use rustc_data_structures::intern::Interned; use rustc_data_structures::intern::Interned;
use rustc_data_structures::sync::{Lrc, RwLock}; use rustc_data_structures::sync::{Lrc, MappedReadGuard};
use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed}; use rustc_errors::{Applicability, DiagnosticBuilder, ErrorGuaranteed};
use rustc_expand::base::{DeriveResolutions, SyntaxExtension, SyntaxExtensionKind}; use rustc_expand::base::{DeriveResolutions, SyntaxExtension, SyntaxExtensionKind};
use rustc_hir::def::Namespace::{self, *}; use rustc_hir::def::Namespace::{self, *};
use rustc_hir::def::{self, CtorOf, DefKind, DocLinkResMap, LifetimeRes, PartialRes, PerNS}; use rustc_hir::def::{self, CtorOf, DefKind, DocLinkResMap, LifetimeRes, PartialRes, PerNS};
use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId}; use rustc_hir::def_id::{CrateNum, DefId, DefIdMap, LocalDefId};
use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE}; use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE};
use rustc_hir::definitions::{DefPathData, Definitions}; use rustc_hir::definitions::DefPathData;
use rustc_hir::TraitCandidate; use rustc_hir::TraitCandidate;
use rustc_index::vec::IndexVec; use rustc_index::vec::IndexVec;
use rustc_metadata::creader::{CStore, CrateLoader}; use rustc_metadata::creader::{CStore, CrateLoader};
use rustc_middle::metadata::ModChild; use rustc_middle::metadata::ModChild;
use rustc_middle::middle::privacy::EffectiveVisibilities; use rustc_middle::middle::privacy::EffectiveVisibilities;
use rustc_middle::span_bug; use rustc_middle::span_bug;
use rustc_middle::ty::{self, DefIdTree, MainDefinition, RegisteredTools}; use rustc_middle::ty::{self, DefIdTree, MainDefinition, RegisteredTools, TyCtxt};
use rustc_middle::ty::{ResolverGlobalCtxt, ResolverOutputs}; use rustc_middle::ty::{ResolverGlobalCtxt, ResolverOutputs};
use rustc_query_system::ich::StableHashingContext; use rustc_query_system::ich::StableHashingContext;
use rustc_session::cstore::{CrateStore, MetadataLoaderDyn, Untracked}; use rustc_session::cstore::CrateStore;
use rustc_session::lint::LintBuffer; use rustc_session::lint::LintBuffer;
use rustc_session::Session;
use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency}; use rustc_span::hygiene::{ExpnId, LocalExpnId, MacroKind, SyntaxContext, Transparency};
use rustc_span::source_map::Spanned; use rustc_span::source_map::Spanned;
use rustc_span::symbol::{kw, sym, Ident, Symbol}; use rustc_span::symbol::{kw, sym, Ident, Symbol};
@ -865,7 +864,7 @@ struct MacroData {
/// ///
/// This is the visitor that walks the whole crate. /// This is the visitor that walks the whole crate.
pub struct Resolver<'a, 'tcx> { pub struct Resolver<'a, 'tcx> {
session: &'tcx Session, tcx: TyCtxt<'tcx>,
/// Item with a given `LocalDefId` was defined during macro expansion with ID `ExpnId`. /// Item with a given `LocalDefId` was defined during macro expansion with ID `ExpnId`.
expn_that_defined: FxHashMap<LocalDefId, ExpnId>, expn_that_defined: FxHashMap<LocalDefId, ExpnId>,
@ -956,9 +955,6 @@ pub struct Resolver<'a, 'tcx> {
arenas: &'a ResolverArenas<'a>, arenas: &'a ResolverArenas<'a>,
dummy_binding: &'a NameBinding<'a>, dummy_binding: &'a NameBinding<'a>,
local_crate_name: Symbol,
metadata_loader: Box<MetadataLoaderDyn>,
untracked: Untracked,
used_extern_options: FxHashSet<Symbol>, used_extern_options: FxHashSet<Symbol>,
macro_names: FxHashSet<Ident>, macro_names: FxHashSet<Ident>,
builtin_macros: FxHashMap<Symbol, BuiltinMacroState>, builtin_macros: FxHashMap<Symbol, BuiltinMacroState>,
@ -1117,27 +1113,10 @@ impl<'a, 'tcx> AsMut<Resolver<'a, 'tcx>> for Resolver<'a, 'tcx> {
} }
} }
/// A minimal subset of resolver that can implemenent `DefIdTree`, sometimes
/// required to satisfy borrow checker by avoiding borrowing the whole resolver.
#[derive(Clone, Copy)]
struct ResolverTree<'a>(&'a Untracked);
impl DefIdTree for ResolverTree<'_> {
#[inline]
fn opt_parent(self, id: DefId) -> Option<DefId> {
let ResolverTree(Untracked { definitions, cstore, .. }) = self;
match id.as_local() {
Some(id) => definitions.read().def_key(id).parent,
None => cstore.as_any().downcast_ref::<CStore>().unwrap().def_key(id).parent,
}
.map(|index| DefId { index, ..id })
}
}
impl<'a, 'b, 'tcx> DefIdTree for &'a Resolver<'b, 'tcx> { impl<'a, 'b, 'tcx> DefIdTree for &'a Resolver<'b, 'tcx> {
#[inline] #[inline]
fn opt_parent(self, id: DefId) -> Option<DefId> { fn opt_parent(self, id: DefId) -> Option<DefId> {
ResolverTree(&self.untracked).opt_parent(id) self.tcx.opt_parent(id)
} }
} }
@ -1164,10 +1143,11 @@ impl<'tcx> Resolver<'_, 'tcx> {
"adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}", "adding a def'n for node-id {:?} and data {:?} but a previous def'n exists: {:?}",
node_id, node_id,
data, data,
self.untracked.definitions.read().def_key(self.node_id_to_def_id[&node_id]), self.tcx.definitions_untracked().def_key(self.node_id_to_def_id[&node_id]),
); );
let def_id = self.untracked.definitions.write().create_def(parent, data); // FIXME: remove `def_span` body, pass in the right spans here and call `tcx.at().create_def()`
let def_id = self.tcx.untracked().definitions.write().create_def(parent, data);
// Create the definition. // Create the definition.
if expn_id != ExpnId::root() { if expn_id != ExpnId::root() {
@ -1176,7 +1156,7 @@ impl<'tcx> Resolver<'_, 'tcx> {
// A relative span's parent must be an absolute span. // A relative span's parent must be an absolute span.
debug_assert_eq!(span.data_untracked().parent, None); debug_assert_eq!(span.data_untracked().parent, None);
let _id = self.untracked.source_span.push(span); let _id = self.tcx.untracked().source_span.write().push(span);
debug_assert_eq!(_id, def_id); debug_assert_eq!(_id, def_id);
// Some things for which we allocate `LocalDefId`s don't correspond to // Some things for which we allocate `LocalDefId`s don't correspond to
@ -1195,17 +1175,19 @@ impl<'tcx> Resolver<'_, 'tcx> {
if let Some(def_id) = def_id.as_local() { if let Some(def_id) = def_id.as_local() {
self.item_generics_num_lifetimes[&def_id] self.item_generics_num_lifetimes[&def_id]
} else { } else {
self.cstore().item_generics_num_lifetimes(def_id, self.session) self.cstore().item_generics_num_lifetimes(def_id, self.tcx.sess)
} }
} }
pub fn tcx(&self) -> TyCtxt<'tcx> {
self.tcx
}
} }
impl<'a, 'tcx> Resolver<'a, 'tcx> { impl<'a, 'tcx> Resolver<'a, 'tcx> {
pub fn new( pub fn new(
session: &'tcx Session, tcx: TyCtxt<'tcx>,
krate: &Crate, krate: &Crate,
crate_name: Symbol,
metadata_loader: Box<MetadataLoaderDyn>,
arenas: &'a ResolverArenas<'a>, arenas: &'a ResolverArenas<'a>,
) -> Resolver<'a, 'tcx> { ) -> Resolver<'a, 'tcx> {
let root_def_id = CRATE_DEF_ID.to_def_id(); let root_def_id = CRATE_DEF_ID.to_def_id();
@ -1215,7 +1197,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
ModuleKind::Def(DefKind::Mod, root_def_id, kw::Empty), ModuleKind::Def(DefKind::Mod, root_def_id, kw::Empty),
ExpnId::root(), ExpnId::root(),
krate.spans.inner_span, krate.spans.inner_span,
session.contains_name(&krate.attrs, sym::no_implicit_prelude), tcx.sess.contains_name(&krate.attrs, sym::no_implicit_prelude),
&mut module_map, &mut module_map,
); );
let empty_module = arenas.new_module( let empty_module = arenas.new_module(
@ -1227,8 +1209,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
&mut FxHashMap::default(), &mut FxHashMap::default(),
); );
let definitions = Definitions::new(session.local_stable_crate_id());
let mut visibilities = FxHashMap::default(); let mut visibilities = FxHashMap::default();
visibilities.insert(CRATE_DEF_ID, ty::Visibility::Public); visibilities.insert(CRATE_DEF_ID, ty::Visibility::Public);
@ -1240,11 +1220,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let mut invocation_parents = FxHashMap::default(); let mut invocation_parents = FxHashMap::default();
invocation_parents.insert(LocalExpnId::ROOT, (CRATE_DEF_ID, ImplTraitContext::Existential)); invocation_parents.insert(LocalExpnId::ROOT, (CRATE_DEF_ID, ImplTraitContext::Existential));
let mut source_span = IndexVec::default(); let mut extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'_>> = tcx
let _id = source_span.push(krate.spans.inner_span); .sess
debug_assert_eq!(_id, CRATE_DEF_ID);
let mut extern_prelude: FxHashMap<Ident, ExternPreludeEntry<'_>> = session
.opts .opts
.externs .externs
.iter() .iter()
@ -1252,19 +1229,19 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
.map(|(name, _)| (Ident::from_str(name), Default::default())) .map(|(name, _)| (Ident::from_str(name), Default::default()))
.collect(); .collect();
if !session.contains_name(&krate.attrs, sym::no_core) { if !tcx.sess.contains_name(&krate.attrs, sym::no_core) {
extern_prelude.insert(Ident::with_dummy_span(sym::core), Default::default()); extern_prelude.insert(Ident::with_dummy_span(sym::core), Default::default());
if !session.contains_name(&krate.attrs, sym::no_std) { if !tcx.sess.contains_name(&krate.attrs, sym::no_std) {
extern_prelude.insert(Ident::with_dummy_span(sym::std), Default::default()); extern_prelude.insert(Ident::with_dummy_span(sym::std), Default::default());
} }
} }
let registered_tools = macros::registered_tools(session, &krate.attrs); let registered_tools = macros::registered_tools(tcx.sess, &krate.attrs);
let features = session.features_untracked(); let features = tcx.sess.features_untracked();
let mut resolver = Resolver { let mut resolver = Resolver {
session, tcx,
expn_that_defined: Default::default(), expn_that_defined: Default::default(),
@ -1318,23 +1295,16 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
vis: ty::Visibility::Public, vis: ty::Visibility::Public,
}), }),
metadata_loader,
local_crate_name: crate_name,
used_extern_options: Default::default(), used_extern_options: Default::default(),
untracked: Untracked {
cstore: Box::new(CStore::new(session)),
source_span,
definitions: RwLock::new(definitions),
},
macro_names: FxHashSet::default(), macro_names: FxHashSet::default(),
builtin_macros: Default::default(), builtin_macros: Default::default(),
builtin_macro_kinds: Default::default(), builtin_macro_kinds: Default::default(),
registered_tools, registered_tools,
macro_use_prelude: FxHashMap::default(), macro_use_prelude: FxHashMap::default(),
macro_map: FxHashMap::default(), macro_map: FxHashMap::default(),
dummy_ext_bang: Lrc::new(SyntaxExtension::dummy_bang(session.edition())), dummy_ext_bang: Lrc::new(SyntaxExtension::dummy_bang(tcx.sess.edition())),
dummy_ext_derive: Lrc::new(SyntaxExtension::dummy_derive(session.edition())), dummy_ext_derive: Lrc::new(SyntaxExtension::dummy_derive(tcx.sess.edition())),
non_macro_attr: Lrc::new(SyntaxExtension::non_macro_attr(session.edition())), non_macro_attr: Lrc::new(SyntaxExtension::non_macro_attr(tcx.sess.edition())),
invocation_parent_scopes: Default::default(), invocation_parent_scopes: Default::default(),
output_macro_rules_scopes: Default::default(), output_macro_rules_scopes: Default::default(),
macro_rules_scopes: Default::default(), macro_rules_scopes: Default::default(),
@ -1430,7 +1400,6 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let main_def = self.main_def; let main_def = self.main_def;
let confused_type_with_std_module = self.confused_type_with_std_module; let confused_type_with_std_module = self.confused_type_with_std_module;
let effective_visibilities = self.effective_visibilities; let effective_visibilities = self.effective_visibilities;
let untracked = self.untracked;
let global_ctxt = ResolverGlobalCtxt { let global_ctxt = ResolverGlobalCtxt {
expn_that_defined, expn_that_defined,
visibilities, visibilities,
@ -1469,26 +1438,21 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
builtin_macro_kinds: self.builtin_macro_kinds, builtin_macro_kinds: self.builtin_macro_kinds,
lifetime_elision_allowed: self.lifetime_elision_allowed, lifetime_elision_allowed: self.lifetime_elision_allowed,
}; };
ResolverOutputs { global_ctxt, ast_lowering, untracked } ResolverOutputs { global_ctxt, ast_lowering }
} }
fn create_stable_hashing_context(&self) -> StableHashingContext<'_> { fn create_stable_hashing_context(&self) -> StableHashingContext<'_> {
StableHashingContext::new(self.session, &self.untracked) StableHashingContext::new(self.tcx.sess, self.tcx.untracked())
} }
fn crate_loader(&mut self) -> CrateLoader<'_> { fn crate_loader<T>(&mut self, f: impl FnOnce(&mut CrateLoader<'_, '_>) -> T) -> T {
CrateLoader::new( let mut cstore = self.tcx.untracked().cstore.write();
&self.session, let cstore = cstore.untracked_as_any().downcast_mut().unwrap();
&*self.metadata_loader, f(&mut CrateLoader::new(self.tcx, &mut *cstore, &mut self.used_extern_options))
self.local_crate_name,
&mut *self.untracked.cstore.untracked_as_any().downcast_mut().unwrap(),
self.untracked.definitions.read(),
&mut self.used_extern_options,
)
} }
fn cstore(&self) -> &CStore { fn cstore(&self) -> MappedReadGuard<'_, CStore> {
self.untracked.cstore.as_any().downcast_ref().unwrap() CStore::from_tcx(self.tcx)
} }
fn dummy_ext(&self, macro_kind: MacroKind) -> Lrc<SyntaxExtension> { fn dummy_ext(&self, macro_kind: MacroKind) -> Lrc<SyntaxExtension> {
@ -1521,18 +1485,25 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
/// Entry point to crate resolution. /// Entry point to crate resolution.
pub fn resolve_crate(&mut self, krate: &Crate) { pub fn resolve_crate(&mut self, krate: &Crate) {
self.session.time("resolve_crate", || { self.tcx.sess.time("resolve_crate", || {
self.session.time("finalize_imports", || ImportResolver { r: self }.finalize_imports()); self.tcx
self.session.time("compute_effective_visibilities", || { .sess
.time("finalize_imports", || ImportResolver { r: self }.finalize_imports());
self.tcx.sess.time("compute_effective_visibilities", || {
EffectiveVisibilitiesVisitor::compute_effective_visibilities(self, krate) EffectiveVisibilitiesVisitor::compute_effective_visibilities(self, krate)
}); });
self.session.time("finalize_macro_resolutions", || self.finalize_macro_resolutions()); self.tcx.sess.time("finalize_macro_resolutions", || self.finalize_macro_resolutions());
self.session.time("late_resolve_crate", || self.late_resolve_crate(krate)); self.tcx.sess.time("late_resolve_crate", || self.late_resolve_crate(krate));
self.session.time("resolve_main", || self.resolve_main()); self.tcx.sess.time("resolve_main", || self.resolve_main());
self.session.time("resolve_check_unused", || self.check_unused(krate)); self.tcx.sess.time("resolve_check_unused", || self.check_unused(krate));
self.session.time("resolve_report_errors", || self.report_errors(krate)); self.tcx.sess.time("resolve_report_errors", || self.report_errors(krate));
self.session.time("resolve_postprocess", || self.crate_loader().postprocess(krate)); self.tcx
.sess
.time("resolve_postprocess", || self.crate_loader(|c| c.postprocess(krate)));
}); });
// Make sure we don't mutate the cstore from here on.
self.tcx.untracked().cstore.leak();
} }
fn traits_in_scope( fn traits_in_scope(
@ -1871,10 +1842,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} else { } else {
let crate_id = if finalize { let crate_id = if finalize {
let Some(crate_id) = let Some(crate_id) =
self.crate_loader().process_path_extern(ident.name, ident.span) else { return Some(self.dummy_binding); }; self.crate_loader(|c| c.process_path_extern(ident.name, ident.span)) else { return Some(self.dummy_binding); };
crate_id crate_id
} else { } else {
self.crate_loader().maybe_process_path_extern(ident.name)? self.crate_loader(|c| c.maybe_process_path_extern(ident.name))?
}; };
let crate_root = self.expect_module(crate_id.as_def_id()); let crate_root = self.expect_module(crate_id.as_def_id());
let vis = ty::Visibility::<LocalDefId>::Public; let vis = ty::Visibility::<LocalDefId>::Public;
@ -1922,14 +1893,14 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
/// Retrieves the span of the given `DefId` if `DefId` is in the local crate. /// Retrieves the span of the given `DefId` if `DefId` is in the local crate.
#[inline] #[inline]
fn opt_span(&self, def_id: DefId) -> Option<Span> { fn opt_span(&self, def_id: DefId) -> Option<Span> {
def_id.as_local().map(|def_id| self.untracked.source_span[def_id]) def_id.as_local().map(|def_id| self.tcx.source_span(def_id))
} }
/// Retrieves the name of the given `DefId`. /// Retrieves the name of the given `DefId`.
#[inline] #[inline]
fn opt_name(&self, def_id: DefId) -> Option<Symbol> { fn opt_name(&self, def_id: DefId) -> Option<Symbol> {
let def_key = match def_id.as_local() { let def_key = match def_id.as_local() {
Some(def_id) => self.untracked.definitions.read().def_key(def_id), Some(def_id) => self.tcx.definitions_untracked().def_key(def_id),
None => self.cstore().def_key(def_id), None => self.cstore().def_key(def_id),
}; };
def_key.get_opt_name() def_key.get_opt_name()
@ -1961,7 +1932,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let attr = self let attr = self
.cstore() .cstore()
.item_attrs_untracked(def_id, self.session) .item_attrs_untracked(def_id, self.tcx.sess)
.find(|a| a.has_name(sym::rustc_legacy_const_generics))?; .find(|a| a.has_name(sym::rustc_legacy_const_generics))?;
let mut ret = Vec::new(); let mut ret = Vec::new();
for meta in attr.meta_item_list()? { for meta in attr.meta_item_list()? {

56
compiler/rustc_resolve/src/macros.rs
View file

@ -195,7 +195,8 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind) { fn register_builtin_macro(&mut self, name: Symbol, ext: SyntaxExtensionKind) {
if self.builtin_macros.insert(name, BuiltinMacroState::NotYetSeen(ext)).is_some() { if self.builtin_macros.insert(name, BuiltinMacroState::NotYetSeen(ext)).is_some() {
self.session self.tcx
.sess
.diagnostic() .diagnostic()
.bug(&format!("built-in macro `{}` was already registered", name)); .bug(&format!("built-in macro `{}` was already registered", name));
} }
@ -216,7 +217,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
ExpnData::allow_unstable( ExpnData::allow_unstable(
ExpnKind::AstPass(pass), ExpnKind::AstPass(pass),
call_site, call_site,
self.session.edition(), self.tcx.sess.edition(),
features.into(), features.into(),
None, None,
parent_module, parent_module,
@ -430,7 +431,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
PathResult::NonModule(..) | PathResult::NonModule(..) |
// HACK(Urgau): This shouldn't be necessary // HACK(Urgau): This shouldn't be necessary
PathResult::Failed { is_error_from_last_segment: false, .. } => { PathResult::Failed { is_error_from_last_segment: false, .. } => {
self.session self.tcx.sess
.struct_span_err(span, "not sure whether the path is accessible or not") .struct_span_err(span, "not sure whether the path is accessible or not")
.note("the type may have associated items, but we are currently not checking them") .note("the type may have associated items, but we are currently not checking them")
.emit(); .emit();
@ -455,7 +456,7 @@ impl<'a, 'tcx> ResolverExpand for Resolver<'a, 'tcx> {
} }
fn get_proc_macro_quoted_span(&self, krate: CrateNum, id: usize) -> Span { fn get_proc_macro_quoted_span(&self, krate: CrateNum, id: usize) -> Span {
self.cstore().get_proc_macro_quoted_span_untracked(krate, id, self.session) self.cstore().get_proc_macro_quoted_span_untracked(krate, id, self.tcx.sess)
} }
fn declare_proc_macro(&mut self, id: NodeId) { fn declare_proc_macro(&mut self, id: NodeId) {
@ -493,10 +494,10 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// Report errors for the resolved macro. // Report errors for the resolved macro.
for segment in &path.segments { for segment in &path.segments {
if let Some(args) = &segment.args { if let Some(args) = &segment.args {
self.session.span_err(args.span(), "generic arguments in macro path"); self.tcx.sess.span_err(args.span(), "generic arguments in macro path");
} }
if kind == MacroKind::Attr && segment.ident.as_str().starts_with("rustc") { if kind == MacroKind::Attr && segment.ident.as_str().starts_with("rustc") {
self.session.span_err( self.tcx.sess.span_err(
segment.ident.span, segment.ident.span,
"attributes starting with `rustc` are reserved for use by the `rustc` compiler", "attributes starting with `rustc` are reserved for use by the `rustc` compiler",
); );
@ -508,7 +509,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if let Some(def_id) = def_id.as_local() { if let Some(def_id) = def_id.as_local() {
self.unused_macros.remove(&def_id); self.unused_macros.remove(&def_id);
if self.proc_macro_stubs.contains(&def_id) { if self.proc_macro_stubs.contains(&def_id) {
self.session.span_err( self.tcx.sess.span_err(
path.span, path.span,
"can't use a procedural macro from the same crate that defines it", "can't use a procedural macro from the same crate that defines it",
); );
@ -540,7 +541,8 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if let Some((article, expected)) = unexpected_res { if let Some((article, expected)) = unexpected_res {
let path_str = pprust::path_to_string(path); let path_str = pprust::path_to_string(path);
let msg = format!("expected {}, found {} `{}`", expected, res.descr(), path_str); let msg = format!("expected {}, found {} `{}`", expected, res.descr(), path_str);
self.session self.tcx
.sess
.struct_span_err(path.span, &msg) .struct_span_err(path.span, &msg)
.span_label(path.span, format!("not {} {}", article, expected)) .span_label(path.span, format!("not {} {}", article, expected))
.emit(); .emit();
@ -550,7 +552,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// We are trying to avoid reporting this error if other related errors were reported. // We are trying to avoid reporting this error if other related errors were reported.
if res != Res::Err if res != Res::Err
&& inner_attr && inner_attr
&& !self.session.features_untracked().custom_inner_attributes && !self.tcx.sess.features_untracked().custom_inner_attributes
{ {
let msg = match res { let msg = match res {
Res::Def(..) => "inner macro attributes are unstable", Res::Def(..) => "inner macro attributes are unstable",
@ -558,10 +560,15 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
_ => unreachable!(), _ => unreachable!(),
}; };
if soft_custom_inner_attributes_gate { if soft_custom_inner_attributes_gate {
self.session.parse_sess.buffer_lint(SOFT_UNSTABLE, path.span, node_id, msg); self.tcx.sess.parse_sess.buffer_lint(SOFT_UNSTABLE, path.span, node_id, msg);
} else { } else {
feature_err(&self.session.parse_sess, sym::custom_inner_attributes, path.span, msg) feature_err(
.emit(); &self.tcx.sess.parse_sess,
sym::custom_inner_attributes,
path.span,
msg,
)
.emit();
} }
} }
@ -655,7 +662,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// Make sure compilation does not succeed if preferred macro resolution // Make sure compilation does not succeed if preferred macro resolution
// has changed after the macro had been expanded. In theory all such // has changed after the macro had been expanded. In theory all such
// situations should be reported as errors, so this is a bug. // situations should be reported as errors, so this is a bug.
this.session.delay_span_bug(span, "inconsistent resolution for a macro"); this.tcx.sess.delay_span_bug(span, "inconsistent resolution for a macro");
} }
} else { } else {
// It's possible that the macro was unresolved (indeterminate) and silently // It's possible that the macro was unresolved (indeterminate) and silently
@ -672,7 +679,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Segment::names_to_string(path) Segment::names_to_string(path)
); );
let msg_note = "import resolution is stuck, try simplifying macro imports"; let msg_note = "import resolution is stuck, try simplifying macro imports";
this.session.struct_span_err(span, &msg).note(msg_note).emit(); this.tcx.sess.struct_span_err(span, &msg).note(msg_note).emit();
} }
} }
}; };
@ -699,7 +706,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
// try to suggest if it's not a macro, maybe a function // try to suggest if it's not a macro, maybe a function
if let PathResult::NonModule(partial_res) = self.maybe_resolve_path(&path, Some(ValueNS), &parent_scope) if let PathResult::NonModule(partial_res) = self.maybe_resolve_path(&path, Some(ValueNS), &parent_scope)
&& partial_res.unresolved_segments() == 0 { && partial_res.unresolved_segments() == 0 {
let sm = self.session.source_map(); let sm = self.tcx.sess.source_map();
let exclamation_span = sm.next_point(span); let exclamation_span = sm.next_point(span);
suggestion = Some(( suggestion = Some((
vec![(exclamation_span, "".to_string())], vec![(exclamation_span, "".to_string())],
@ -762,7 +769,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
Err(..) => { Err(..) => {
let expected = kind.descr_expected(); let expected = kind.descr_expected();
let msg = format!("cannot find {} `{}` in this scope", expected, ident); let msg = format!("cannot find {} `{}` in this scope", expected, ident);
let mut err = self.session.struct_span_err(ident.span, &msg); let mut err = self.tcx.sess.struct_span_err(ident.span, &msg);
self.unresolved_macro_suggestions(&mut err, kind, &parent_scope, ident); self.unresolved_macro_suggestions(&mut err, kind, &parent_scope, ident);
err.emit(); err.emit();
} }
@ -804,7 +811,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
let soft_handler = let soft_handler =
|lint, span, msg: &_| lint_buffer.buffer_lint(lint, node_id, span, msg); |lint, span, msg: &_| lint_buffer.buffer_lint(lint, node_id, span, msg);
stability::report_unstable( stability::report_unstable(
self.session, self.tcx.sess,
feature, feature,
reason.to_opt_reason(), reason.to_opt_reason(),
issue, issue,
@ -840,7 +847,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if kind != NonMacroAttrKind::Tool && binding.map_or(true, |b| b.is_import()) { if kind != NonMacroAttrKind::Tool && binding.map_or(true, |b| b.is_import()) {
let msg = let msg =
format!("cannot use {} {} through an import", kind.article(), kind.descr()); format!("cannot use {} {} through an import", kind.article(), kind.descr());
let mut err = self.session.struct_span_err(span, &msg); let mut err = self.tcx.sess.struct_span_err(span, &msg);
if let Some(binding) = binding { if let Some(binding) = binding {
err.span_note(binding.span, &format!("the {} imported here", kind.descr())); err.span_note(binding.span, &format!("the {} imported here", kind.descr()));
} }
@ -855,7 +862,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
if ident.name == sym::cfg || ident.name == sym::cfg_attr { if ident.name == sym::cfg || ident.name == sym::cfg_attr {
let macro_kind = self.get_macro(res).map(|macro_data| macro_data.ext.macro_kind()); let macro_kind = self.get_macro(res).map(|macro_data| macro_data.ext.macro_kind());
if macro_kind.is_some() && sub_namespace_match(macro_kind, Some(MacroKind::Attr)) { if macro_kind.is_some() && sub_namespace_match(macro_kind, Some(MacroKind::Attr)) {
self.session.span_err( self.tcx.sess.span_err(
ident.span, ident.span,
&format!("name `{}` is reserved in attribute namespace", ident), &format!("name `{}` is reserved in attribute namespace", ident),
); );
@ -871,12 +878,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
item: &ast::Item, item: &ast::Item,
edition: Edition, edition: Edition,
) -> (SyntaxExtension, Vec<(usize, Span)>) { ) -> (SyntaxExtension, Vec<(usize, Span)>) {
let (mut result, mut rule_spans) = compile_declarative_macro( let (mut result, mut rule_spans) = compile_declarative_macro(self.tcx.sess, item, edition);
&self.session,
self.session.features_untracked(),
item,
edition,
);
if let Some(builtin_name) = result.builtin_name { if let Some(builtin_name) = result.builtin_name {
// The macro was marked with `#[rustc_builtin_macro]`. // The macro was marked with `#[rustc_builtin_macro]`.
@ -895,7 +897,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
BuiltinMacroState::AlreadySeen(span) => { BuiltinMacroState::AlreadySeen(span) => {
struct_span_err!( struct_span_err!(
self.session, self.tcx.sess,
item.span, item.span,
E0773, E0773,
"attempted to define built-in macro more than once" "attempted to define built-in macro more than once"
@ -906,7 +908,7 @@ impl<'a, 'tcx> Resolver<'a, 'tcx> {
} }
} else { } else {
let msg = format!("cannot find a built-in macro with name `{}`", item.ident); let msg = format!("cannot find a built-in macro with name `{}`", item.ident);
self.session.span_err(item.span, &msg); self.tcx.sess.span_err(item.span, &msg);
} }
} }

10
compiler/rustc_session/src/cstore.rs
View file

@ -200,12 +200,12 @@ pub enum ExternCrateSource {
/// At the time of this writing, there is only one backend and one way to store /// At the time of this writing, there is only one backend and one way to store
/// metadata in library -- this trait just serves to decouple rustc_metadata from /// metadata in library -- this trait just serves to decouple rustc_metadata from
/// the archive reader, which depends on LLVM. /// the archive reader, which depends on LLVM.
pub trait MetadataLoader { pub trait MetadataLoader: std::fmt::Debug {
fn get_rlib_metadata(&self, target: &Target, filename: &Path) -> Result<MetadataRef, String>; fn get_rlib_metadata(&self, target: &Target, filename: &Path) -> Result<MetadataRef, String>;
fn get_dylib_metadata(&self, target: &Target, filename: &Path) -> Result<MetadataRef, String>; fn get_dylib_metadata(&self, target: &Target, filename: &Path) -> Result<MetadataRef, String>;
} }
pub type MetadataLoaderDyn = dyn MetadataLoader + Sync; pub type MetadataLoaderDyn = dyn MetadataLoader + Send + Sync;
/// A store of Rust crates, through which their metadata can be accessed. /// A store of Rust crates, through which their metadata can be accessed.
/// ///
@ -250,12 +250,12 @@ pub trait CrateStore: std::fmt::Debug {
fn import_source_files(&self, sess: &Session, cnum: CrateNum); fn import_source_files(&self, sess: &Session, cnum: CrateNum);
} }
pub type CrateStoreDyn = dyn CrateStore + sync::Sync; pub type CrateStoreDyn = dyn CrateStore + sync::Sync + sync::Send;
#[derive(Debug)] #[derive(Debug)]
pub struct Untracked { pub struct Untracked {
pub cstore: Box<CrateStoreDyn>, pub cstore: RwLock<Box<CrateStoreDyn>>,
/// Reference span for definitions. /// Reference span for definitions.
pub source_span: IndexVec<LocalDefId, Span>, pub source_span: RwLock<IndexVec<LocalDefId, Span>>,
pub definitions: RwLock<Definitions>, pub definitions: RwLock<Definitions>,
} }

4
tests/rustdoc-ui/bounded-hr-lifetime.stderr
View file

@ -4,7 +4,5 @@ error: lifetime bounds cannot be used in this context
LL | for<'a: 'b + 'c> &'a (): std::fmt::Debug, LL | for<'a: 'b + 'c> &'a (): std::fmt::Debug,
| ^^ ^^ | ^^ ^^
error: Compilation failed, aborting rustdoc error: aborting due to previous error
error: aborting due to 2 previous errors

4
tests/rustdoc-ui/feature-gate-doc_cfg_hide.stderr
View file

@ -7,8 +7,6 @@ LL | #![doc(cfg_hide(test))]
= note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information = note: see issue #43781 <https://github.com/rust-lang/rust/issues/43781> for more information
= help: add `#![feature(doc_cfg_hide)]` to the crate attributes to enable = help: add `#![feature(doc_cfg_hide)]` to the crate attributes to enable
error: Compilation failed, aborting rustdoc error: aborting due to previous error
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0658`. For more information about this error, try `rustc --explain E0658`.

4
tests/rustdoc-ui/feature-gate-rustdoc_missing_doc_code_examples.rs
View file

@ -1,10 +1,12 @@
#![deny(unknown_lints)] #![deny(unknown_lints)]
//~^ NOTE defined here //~^ NOTE defined here
#![allow(rustdoc::missing_doc_code_examples)] #![allow(rustdoc::missing_doc_code_examples)]
//~^ ERROR unknown lint //~^ ERROR unknown lint
//~| ERROR unknown lint //~| ERROR unknown lint
//~| ERROR unknown lint
//~| NOTE lint is unstable
//~| NOTE lint is unstable //~| NOTE lint is unstable
//~| NOTE lint is unstable //~| NOTE lint is unstable
//~| NOTE see issue //~| NOTE see issue
//~| NOTE see issue //~| NOTE see issue
//~| NOTE see issue

14
tests/rustdoc-ui/feature-gate-rustdoc_missing_doc_code_examples.stderr
View file

@ -1,5 +1,5 @@
error: unknown lint: `rustdoc::missing_doc_code_examples` error: unknown lint: `rustdoc::missing_doc_code_examples`
--> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:4:1 --> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:3:1
| |
LL | #![allow(rustdoc::missing_doc_code_examples)] LL | #![allow(rustdoc::missing_doc_code_examples)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -14,7 +14,7 @@ LL | #![deny(unknown_lints)]
| ^^^^^^^^^^^^^ | ^^^^^^^^^^^^^
error: unknown lint: `rustdoc::missing_doc_code_examples` error: unknown lint: `rustdoc::missing_doc_code_examples`
--> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:4:1 --> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:3:1
| |
LL | #![allow(rustdoc::missing_doc_code_examples)] LL | #![allow(rustdoc::missing_doc_code_examples)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -23,7 +23,15 @@ LL | #![allow(rustdoc::missing_doc_code_examples)]
= note: see issue #101730 <https://github.com/rust-lang/rust/issues/101730> for more information = note: see issue #101730 <https://github.com/rust-lang/rust/issues/101730> for more information
= help: add `#![feature(rustdoc_missing_doc_code_examples)]` to the crate attributes to enable = help: add `#![feature(rustdoc_missing_doc_code_examples)]` to the crate attributes to enable
error: Compilation failed, aborting rustdoc error: unknown lint: `rustdoc::missing_doc_code_examples`
--> $DIR/feature-gate-rustdoc_missing_doc_code_examples.rs:3:1
|
LL | #![allow(rustdoc::missing_doc_code_examples)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: the `rustdoc::missing_doc_code_examples` lint is unstable
= note: see issue #101730 <https://github.com/rust-lang/rust/issues/101730> for more information
= help: add `#![feature(rustdoc_missing_doc_code_examples)]` to the crate attributes to enable
error: aborting due to 3 previous errors error: aborting due to 3 previous errors

4
tests/rustdoc-ui/impl-fn-nesting.stderr
View file

@ -58,9 +58,7 @@ error[E0412]: cannot find type `UnknownType` in this scope
LL | pub fn doubly_nested(c: UnknownType) { LL | pub fn doubly_nested(c: UnknownType) {
| ^^^^^^^^^^^ not found in this scope | ^^^^^^^^^^^ not found in this scope
error: Compilation failed, aborting rustdoc error: aborting due to 10 previous errors
error: aborting due to 11 previous errors
Some errors have detailed explanations: E0405, E0412. Some errors have detailed explanations: E0405, E0412.
For more information about an error, try `rustc --explain E0405`. For more information about an error, try `rustc --explain E0405`.

4
tests/rustdoc-ui/intra-doc/unresolved-import-recovery.stderr
View file

@ -6,8 +6,6 @@ LL | use unresolved_crate::module::Name;
| |
= help: consider adding `extern crate unresolved_crate` to use the `unresolved_crate` crate = help: consider adding `extern crate unresolved_crate` to use the `unresolved_crate` crate
error: Compilation failed, aborting rustdoc error: aborting due to previous error
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0433`. For more information about this error, try `rustc --explain E0433`.

4
tests/rustdoc-ui/issue-61732.stderr
View file

@ -6,8 +6,6 @@ LL | pub(in crate::r#mod) fn main() {}
| |
= help: consider adding `extern crate r#mod` to use the `r#mod` crate = help: consider adding `extern crate r#mod` to use the `r#mod` crate
error: Compilation failed, aborting rustdoc error: aborting due to previous error
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0433`. For more information about this error, try `rustc --explain E0433`.

4
tests/rustdoc-ui/unknown-renamed-lints.stderr
View file

@ -58,7 +58,5 @@ error: unknown lint: `rustdoc::intra_doc_link_resolution_failure`
LL | #![deny(rustdoc::intra_doc_link_resolution_failure)] LL | #![deny(rustdoc::intra_doc_link_resolution_failure)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
error: Compilation failed, aborting rustdoc error: aborting due to 8 previous errors
error: aborting due to 9 previous errors

1
tests/ui/panics/default-backtrace-ice.stderr
View file

@ -13,4 +13,5 @@ error: the compiler unexpectedly panicked. this is a bug.
query stack during panic: query stack during panic:
#0 [resolver_for_lowering] getting the resolver for lowering
end of query stack end of query stack