Skip to content

Commit 504225c

Browse files
Dylan-DPCDylan-DPC
authored
Rollup merge of #108032 - oli-obk:un📦ing_resolver, r=petrochenkov
Un📦ing the Resolver r? `@petrochenkov` pulled out of #105462
2 parents 587e3df + 241c6a4 commit 504225c

14 files changed

+97
-177
lines changed

‎compiler/rustc_interface/src/interface.rs

-1
Original file line numberDiff line numberDiff line change
@@ -1,4 +1,3 @@
1-
pub use crate::passes::BoxedResolver;
21
use crate::util;
32

43
use rustc_ast::token;

‎compiler/rustc_interface/src/passes.rs

+3-83
Original file line numberDiff line numberDiff line change
@@ -23,9 +23,9 @@ use rustc_parse::{parse_crate_from_file, parse_crate_from_source_str, validate_a
2323
use rustc_passes::{self, hir_stats, layout_test};
2424
use rustc_plugin_impl as plugin;
2525
use rustc_query_impl::{OnDiskCache, Queries as TcxQueries};
26-
use rustc_resolve::{Resolver, ResolverArenas};
26+
use rustc_resolve::Resolver;
2727
use rustc_session::config::{CrateType, Input, OutputFilenames, OutputType};
28-
use rustc_session::cstore::{CrateStoreDyn, MetadataLoader, MetadataLoaderDyn, Untracked};
28+
use rustc_session::cstore::{CrateStoreDyn, MetadataLoader, Untracked};
2929
use rustc_session::output::filename_for_input;
3030
use rustc_session::search_paths::PathKind;
3131
use rustc_session::{Limit, Session};
@@ -37,9 +37,7 @@ use rustc_trait_selection::traits;
3737
use std::any::Any;
3838
use std::ffi::OsString;
3939
use std::io::{self, BufWriter, Write};
40-
use std::marker::PhantomPinned;
4140
use std::path::{Path, PathBuf};
42-
use std::pin::Pin;
4341
use std::sync::{Arc, LazyLock};
4442
use std::{env, fs, iter};
4543

@@ -73,84 +71,6 @@ fn count_nodes(krate: &ast::Crate) -> usize {
7371
counter.count
7472
}
7573

76-
pub use boxed_resolver::BoxedResolver;
77-
mod boxed_resolver {
78-
use super::*;
79-
80-
pub struct BoxedResolver(Pin<Box<BoxedResolverInner>>);
81-
82-
struct BoxedResolverInner {
83-
session: Lrc<Session>,
84-
resolver_arenas: Option<ResolverArenas<'static>>,
85-
resolver: Option<Resolver<'static>>,
86-
_pin: PhantomPinned,
87-
}
88-
89-
// Note: Drop order is important to prevent dangling references. Resolver must be dropped first,
90-
// then resolver_arenas and session.
91-
impl Drop for BoxedResolverInner {
92-
fn drop(&mut self) {
93-
self.resolver.take();
94-
self.resolver_arenas.take();
95-
}
96-
}
97-
98-
impl BoxedResolver {
99-
pub(super) fn new(
100-
session: Lrc<Session>,
101-
make_resolver: impl for<'a> FnOnce(&'a Session, &'a ResolverArenas<'a>) -> Resolver<'a>,
102-
) -> BoxedResolver {
103-
let mut boxed_resolver = Box::new(BoxedResolverInner {
104-
session,
105-
resolver_arenas: Some(Resolver::arenas()),
106-
resolver: None,
107-
_pin: PhantomPinned,
108-
});
109-
// SAFETY: `make_resolver` takes a resolver arena with an arbitrary lifetime and
110-
// returns a resolver with the same lifetime as the arena. We ensure that the arena
111-
// outlives the resolver in the drop impl and elsewhere so these transmutes are sound.
112-
unsafe {
113-
let resolver = make_resolver(
114-
std::mem::transmute::<&Session, &Session>(&boxed_resolver.session),
115-
std::mem::transmute::<&ResolverArenas<'_>, &ResolverArenas<'_>>(
116-
boxed_resolver.resolver_arenas.as_ref().unwrap(),
117-
),
118-
);
119-
boxed_resolver.resolver = Some(resolver);
120-
BoxedResolver(Pin::new_unchecked(boxed_resolver))
121-
}
122-
}
123-
124-
pub fn access<F: for<'a> FnOnce(&mut Resolver<'a>) -> R, R>(&mut self, f: F) -> R {
125-
// SAFETY: The resolver doesn't need to be pinned.
126-
let mut resolver = unsafe {
127-
self.0.as_mut().map_unchecked_mut(|boxed_resolver| &mut boxed_resolver.resolver)
128-
};
129-
f((&mut *resolver).as_mut().unwrap())
130-
}
131-
132-
pub fn into_outputs(mut self) -> ty::ResolverOutputs {
133-
// SAFETY: The resolver doesn't need to be pinned.
134-
let mut resolver = unsafe {
135-
self.0.as_mut().map_unchecked_mut(|boxed_resolver| &mut boxed_resolver.resolver)
136-
};
137-
resolver.take().unwrap().into_outputs()
138-
}
139-
}
140-
}
141-
142-
pub fn create_resolver(
143-
sess: Lrc<Session>,
144-
metadata_loader: Box<MetadataLoaderDyn>,
145-
krate: &ast::Crate,
146-
crate_name: Symbol,
147-
) -> BoxedResolver {
148-
trace!("create_resolver");
149-
BoxedResolver::new(sess, move |sess, resolver_arenas| {
150-
Resolver::new(sess, krate, crate_name, metadata_loader, resolver_arenas)
151-
})
152-
}
153-
15474
pub fn register_plugins<'a>(
15575
sess: &'a Session,
15676
metadata_loader: &'a dyn MetadataLoader,
@@ -256,7 +176,7 @@ pub fn configure_and_expand(
256176
lint_store: &LintStore,
257177
mut krate: ast::Crate,
258178
crate_name: Symbol,
259-
resolver: &mut Resolver<'_>,
179+
resolver: &mut Resolver<'_, '_>,
260180
) -> Result<ast::Crate> {
261181
trace!("configure_and_expand");
262182
pre_expansion_lint(sess, lint_store, resolver.registered_tools(), &krate, crate_name);

‎compiler/rustc_interface/src/queries.rs

+25-27
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,6 @@
11
use crate::errors::{FailedWritingFile, RustcErrorFatal, RustcErrorUnexpectedAnnotation};
22
use crate::interface::{Compiler, Result};
3-
use crate::passes::{self, BoxedResolver};
3+
use crate::passes;
44

55
use rustc_ast as ast;
66
use rustc_codegen_ssa::traits::CodegenBackend;
@@ -15,6 +15,7 @@ use rustc_middle::arena::Arena;
1515
use rustc_middle::dep_graph::DepGraph;
1616
use rustc_middle::ty::{self, GlobalCtxt, TyCtxt};
1717
use rustc_query_impl::Queries as TcxQueries;
18+
use rustc_resolve::Resolver;
1819
use rustc_session::config::{self, OutputFilenames, OutputType};
1920
use rustc_session::{output::find_crate_name, Session};
2021
use rustc_span::symbol::sym;
@@ -87,7 +88,6 @@ pub struct Queries<'tcx> {
8788
parse: Query<ast::Crate>,
8889
crate_name: Query<Symbol>,
8990
register_plugins: Query<(ast::Crate, Lrc<LintStore>)>,
90-
expansion: Query<(Lrc<ast::Crate>, BoxedResolver, Lrc<LintStore>)>,
9191
dep_graph: Query<DepGraph>,
9292
// This just points to what's in `gcx_cell`.
9393
gcx: Query<&'tcx GlobalCtxt<'tcx>>,
@@ -106,7 +106,6 @@ impl<'tcx> Queries<'tcx> {
106106
parse: Default::default(),
107107
crate_name: Default::default(),
108108
register_plugins: Default::default(),
109-
expansion: Default::default(),
110109
dep_graph: Default::default(),
111110
gcx: Default::default(),
112111
ongoing_codegen: Default::default(),
@@ -168,28 +167,6 @@ impl<'tcx> Queries<'tcx> {
168167
})
169168
}
170169

171-
pub fn expansion(
172-
&self,
173-
) -> Result<QueryResult<'_, (Lrc<ast::Crate>, BoxedResolver, Lrc<LintStore>)>> {
174-
trace!("expansion");
175-
self.expansion.compute(|| {
176-
let crate_name = *self.crate_name()?.borrow();
177-
let (krate, lint_store) = self.register_plugins()?.steal();
178-
let _timer = self.session().timer("configure_and_expand");
179-
let sess = self.session();
180-
let mut resolver = passes::create_resolver(
181-
sess.clone(),
182-
self.codegen_backend().metadata_loader(),
183-
&krate,
184-
crate_name,
185-
);
186-
let krate = resolver.access(|resolver| {
187-
passes::configure_and_expand(sess, &lint_store, krate, crate_name, resolver)
188-
})?;
189-
Ok((Lrc::new(krate), resolver, lint_store))
190-
})
191-
}
192-
193170
fn dep_graph(&self) -> Result<QueryResult<'_, DepGraph>> {
194171
self.dep_graph.compute(|| {
195172
let sess = self.session();
@@ -209,13 +186,34 @@ impl<'tcx> Queries<'tcx> {
209186
pub fn global_ctxt(&'tcx self) -> Result<QueryResult<'_, &'tcx GlobalCtxt<'tcx>>> {
210187
self.gcx.compute(|| {
211188
let crate_name = *self.crate_name()?.borrow();
212-
let (krate, resolver, lint_store) = self.expansion()?.steal();
189+
let (krate, lint_store) = self.register_plugins()?.steal();
190+
let (krate, resolver_outputs) = {
191+
let _timer = self.session().timer("configure_and_expand");
192+
let sess = self.session();
193+
194+
let arenas = Resolver::arenas();
195+
let mut resolver = Resolver::new(
196+
sess,
197+
&krate,
198+
crate_name,
199+
self.codegen_backend().metadata_loader(),
200+
&arenas,
201+
);
202+
let krate = passes::configure_and_expand(
203+
sess,
204+
&lint_store,
205+
krate,
206+
crate_name,
207+
&mut resolver,
208+
)?;
209+
(Lrc::new(krate), resolver.into_outputs())
210+
};
213211

214212
let ty::ResolverOutputs {
215213
untracked,
216214
global_ctxt: untracked_resolutions,
217215
ast_lowering: untracked_resolver_for_lowering,
218-
} = resolver.into_outputs();
216+
} = resolver_outputs;
219217

220218
let gcx = passes::create_global_ctxt(
221219
self.compiler,

‎compiler/rustc_resolve/src/build_reduced_graph.rs

+7-7
Original file line numberDiff line numberDiff line change
@@ -65,7 +65,7 @@ impl<'a, Id: Into<DefId>> ToNameBinding<'a> for (Res, ty::Visibility<Id>, Span,
6565
}
6666
}
6767

68-
impl<'a> Resolver<'a> {
68+
impl<'a, 'tcx> Resolver<'a, 'tcx> {
6969
/// Defines `name` in namespace `ns` of module `parent` to be `def` if it is not yet defined;
7070
/// otherwise, reports an error.
7171
pub(crate) fn define<T>(&mut self, parent: Module<'a>, ident: Ident, ns: Namespace, def: T)
@@ -214,18 +214,18 @@ impl<'a> Resolver<'a> {
214214
}
215215
}
216216

217-
struct BuildReducedGraphVisitor<'a, 'b> {
218-
r: &'b mut Resolver<'a>,
217+
struct BuildReducedGraphVisitor<'a, 'b, 'tcx> {
218+
r: &'b mut Resolver<'a, 'tcx>,
219219
parent_scope: ParentScope<'a>,
220220
}
221221

222-
impl<'a> AsMut<Resolver<'a>> for BuildReducedGraphVisitor<'a, '_> {
223-
fn as_mut(&mut self) -> &mut Resolver<'a> {
222+
impl<'a, 'tcx> AsMut<Resolver<'a, 'tcx>> for BuildReducedGraphVisitor<'a, '_, 'tcx> {
223+
fn as_mut(&mut self) -> &mut Resolver<'a, 'tcx> {
224224
self.r
225225
}
226226
}
227227

228-
impl<'a, 'b> BuildReducedGraphVisitor<'a, 'b> {
228+
impl<'a, 'b, 'tcx> BuildReducedGraphVisitor<'a, 'b, 'tcx> {
229229
fn resolve_visibility(&mut self, vis: &ast::Visibility) -> ty::Visibility {
230230
self.try_resolve_visibility(vis, true).unwrap_or_else(|err| {
231231
self.r.report_vis_error(err);
@@ -1315,7 +1315,7 @@ macro_rules! method {
13151315
};
13161316
}
13171317

1318-
impl<'a, 'b> Visitor<'b> for BuildReducedGraphVisitor<'a, 'b> {
1318+
impl<'a, 'b, 'tcx> Visitor<'b> for BuildReducedGraphVisitor<'a, 'b, 'tcx> {
13191319
method!(visit_expr: ast::Expr, ast::ExprKind::MacCall, walk_expr);
13201320
method!(visit_pat: ast::Pat, ast::PatKind::MacCall, walk_pat);
13211321
method!(visit_ty: ast::Ty, ast::TyKind::MacCall, walk_ty);

‎compiler/rustc_resolve/src/check_unused.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -49,16 +49,16 @@ impl<'a> UnusedImport<'a> {
4949
}
5050
}
5151

52-
struct UnusedImportCheckVisitor<'a, 'b> {
53-
r: &'a mut Resolver<'b>,
52+
struct UnusedImportCheckVisitor<'a, 'b, 'tcx> {
53+
r: &'a mut Resolver<'b, 'tcx>,
5454
/// All the (so far) unused imports, grouped path list
5555
unused_imports: FxIndexMap<ast::NodeId, UnusedImport<'a>>,
5656
base_use_tree: Option<&'a ast::UseTree>,
5757
base_id: ast::NodeId,
5858
item_span: Span,
5959
}
6060

61-
impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
61+
impl<'a, 'b, 'tcx> UnusedImportCheckVisitor<'a, 'b, 'tcx> {
6262
// We have information about whether `use` (import) items are actually
6363
// used now. If an import is not used at all, we signal a lint error.
6464
fn check_import(&mut self, id: ast::NodeId) {
@@ -94,7 +94,7 @@ impl<'a, 'b> UnusedImportCheckVisitor<'a, 'b> {
9494
}
9595
}
9696

97-
impl<'a, 'b> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b> {
97+
impl<'a, 'b, 'tcx> Visitor<'a> for UnusedImportCheckVisitor<'a, 'b, 'tcx> {
9898
fn visit_item(&mut self, item: &'a ast::Item) {
9999
self.item_span = item.span_with_attributes();
100100

@@ -222,7 +222,7 @@ fn calc_unused_spans(
222222
}
223223
}
224224

225-
impl Resolver<'_> {
225+
impl Resolver<'_, '_> {
226226
pub(crate) fn check_unused(&mut self, krate: &ast::Crate) {
227227
for import in self.potentially_unused_imports.iter() {
228228
match import.kind {

‎compiler/rustc_resolve/src/def_collector.rs

+5-5
Original file line numberDiff line numberDiff line change
@@ -9,7 +9,7 @@ use rustc_span::symbol::sym;
99
use rustc_span::Span;
1010

1111
pub(crate) fn collect_definitions(
12-
resolver: &mut Resolver<'_>,
12+
resolver: &mut Resolver<'_, '_>,
1313
fragment: &AstFragment,
1414
expansion: LocalExpnId,
1515
) {
@@ -18,14 +18,14 @@ pub(crate) fn collect_definitions(
1818
}
1919

2020
/// Creates `DefId`s for nodes in the AST.
21-
struct DefCollector<'a, 'b> {
22-
resolver: &'a mut Resolver<'b>,
21+
struct DefCollector<'a, 'b, 'tcx> {
22+
resolver: &'a mut Resolver<'b, 'tcx>,
2323
parent_def: LocalDefId,
2424
impl_trait_context: ImplTraitContext,
2525
expansion: LocalExpnId,
2626
}
2727

28-
impl<'a, 'b> DefCollector<'a, 'b> {
28+
impl<'a, 'b, 'tcx> DefCollector<'a, 'b, 'tcx> {
2929
fn create_def(&mut self, node_id: NodeId, data: DefPathData, span: Span) -> LocalDefId {
3030
let parent_def = self.parent_def;
3131
debug!("create_def(node_id={:?}, data={:?}, parent_def={:?})", node_id, data, parent_def);
@@ -81,7 +81,7 @@ impl<'a, 'b> DefCollector<'a, 'b> {
8181
}
8282
}
8383

84-
impl<'a, 'b> visit::Visitor<'a> for DefCollector<'a, 'b> {
84+
impl<'a, 'b, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'b, 'tcx> {
8585
fn visit_item(&mut self, i: &'a Item) {
8686
debug!("visit_item: {:?}", i);
8787

‎compiler/rustc_resolve/src/diagnostics.rs

+2-2
Original file line numberDiff line numberDiff line change
@@ -114,7 +114,7 @@ fn reduce_impl_span_to_impl_keyword(sm: &SourceMap, impl_span: Span) -> Span {
114114
sm.span_until_whitespace(impl_span)
115115
}
116116

117-
impl<'a> Resolver<'a> {
117+
impl<'a, 'tcx> Resolver<'a, 'tcx> {
118118
pub(crate) fn report_errors(&mut self, krate: &Crate) {
119119
self.report_with_use_injections(krate);
120120

@@ -1883,7 +1883,7 @@ impl<'a> Resolver<'a> {
18831883
}
18841884
}
18851885

1886-
impl<'a, 'b> ImportResolver<'a, 'b> {
1886+
impl<'a, 'b, 'tcx> ImportResolver<'a, 'b, 'tcx> {
18871887
/// Adds suggestions for a path that cannot be resolved.
18881888
pub(crate) fn make_path_suggestion(
18891889
&mut self,

0 commit comments

Comments
 (0)