use rustc_ast as ast;
use rustc_codegen_ssa::traits::CodegenBackend;
use rustc_codegen_ssa::CodegenResults;
+use rustc_data_structures::steal::Steal;
use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::{Lrc, OnceCell, WorkerLocal};
use rustc_hir::def_id::LOCAL_CRATE;
use rustc_span::symbol::sym;
use rustc_span::Symbol;
use std::any::Any;
-use std::cell::{Ref, RefCell, RefMut};
+use std::cell::{RefCell, RefMut};
use std::rc::Rc;
use std::sync::Arc;
/// Represent the result of a query.
///
-/// This result can be stolen with the [`take`] method and generated with the [`compute`] method.
+/// This result can be stolen once with the [`steal`] method and generated with the [`compute`] method.
///
-/// [`take`]: Self::take
+/// [`steal`]: Steal::steal
/// [`compute`]: Self::compute
pub struct Query<T> {
- result: RefCell<Option<Result<T>>>,
+ /// `None` means no value has been computed yet.
+ result: RefCell<Option<Result<Steal<T>>>>,
}
impl<T> Query<T> {
- fn compute<F: FnOnce() -> Result<T>>(&self, f: F) -> Result<&Query<T>> {
- self.result.borrow_mut().get_or_insert_with(f).as_ref().map(|_| self).map_err(|&err| err)
+ fn compute<F: FnOnce() -> Result<T>>(&self, f: F) -> Result<QueryResult<'_, T>> {
+ RefMut::filter_map(
+ self.result.borrow_mut(),
+ |r: &mut Option<Result<Steal<T>>>| -> Option<&mut Steal<T>> {
+ r.get_or_insert_with(|| f().map(Steal::new)).as_mut().ok()
+ },
+ )
+ .map_err(|r| *r.as_ref().unwrap().as_ref().map(|_| ()).unwrap_err())
+ .map(QueryResult)
}
+}
+
+pub struct QueryResult<'a, T>(RefMut<'a, Steal<T>>);
+
+impl<'a, T> std::ops::Deref for QueryResult<'a, T> {
+ type Target = RefMut<'a, Steal<T>>;
- /// Takes ownership of the query result. Further attempts to take or peek the query
- /// result will panic unless it is generated by calling the `compute` method.
- pub fn take(&self) -> T {
- self.result.borrow_mut().take().expect("missing query result").unwrap()
+ fn deref(&self) -> &Self::Target {
+ &self.0
}
+}
- /// Borrows the query result using the RefCell. Panics if the result is stolen.
- pub fn peek(&self) -> Ref<'_, T> {
- Ref::map(self.result.borrow(), |r| {
- r.as_ref().unwrap().as_ref().expect("missing query result")
- })
+impl<'a, T> std::ops::DerefMut for QueryResult<'a, T> {
+ fn deref_mut(&mut self) -> &mut Self::Target {
+ &mut self.0
}
+}
- /// Mutably borrows the query result using the RefCell. Panics if the result is stolen.
- pub fn peek_mut(&self) -> RefMut<'_, T> {
- RefMut::map(self.result.borrow_mut(), |r| {
- r.as_mut().unwrap().as_mut().expect("missing query result")
- })
+impl<'a, 'tcx> QueryResult<'a, QueryContext<'tcx>> {
+ pub fn enter<T>(mut self, f: impl FnOnce(TyCtxt<'tcx>) -> T) -> T {
+ (*self.0).get_mut().enter(f)
}
}
self.compiler.codegen_backend()
}
- fn dep_graph_future(&self) -> Result<&Query<Option<DepGraphFuture>>> {
+ fn dep_graph_future(&self) -> Result<QueryResult<'_, Option<DepGraphFuture>>> {
self.dep_graph_future.compute(|| {
let sess = self.session();
Ok(sess.opts.build_dep_graph().then(|| rustc_incremental::load_dep_graph(sess)))
})
}
- pub fn parse(&self) -> Result<&Query<ast::Crate>> {
+ pub fn parse(&self) -> Result<QueryResult<'_, ast::Crate>> {
self.parse.compute(|| {
passes::parse(self.session(), &self.compiler.input)
.map_err(|mut parse_error| parse_error.emit())
})
}
- pub fn register_plugins(&self) -> Result<&Query<(ast::Crate, Lrc<LintStore>)>> {
+ pub fn register_plugins(&self) -> Result<QueryResult<'_, (ast::Crate, Lrc<LintStore>)>> {
self.register_plugins.compute(|| {
- let crate_name = *self.crate_name()?.peek();
- let krate = self.parse()?.take();
+ let crate_name = *self.crate_name()?.borrow();
+ let krate = self.parse()?.steal();
let empty: &(dyn Fn(&Session, &mut LintStore) + Sync + Send) = &|_, _| {};
let (krate, lint_store) = passes::register_plugins(
})
}
- pub fn crate_name(&self) -> Result<&Query<Symbol>> {
+ pub fn crate_name(&self) -> Result<QueryResult<'_, Symbol>> {
self.crate_name.compute(|| {
Ok({
let parse_result = self.parse()?;
- let krate = parse_result.peek();
+ let krate = parse_result.borrow();
// parse `#[crate_name]` even if `--crate-name` was passed, to make sure it matches.
find_crate_name(self.session(), &krate.attrs, &self.compiler.input)
})
pub fn expansion(
&self,
- ) -> Result<&Query<(Lrc<ast::Crate>, Rc<RefCell<BoxedResolver>>, Lrc<LintStore>)>> {
+ ) -> Result<QueryResult<'_, (Lrc<ast::Crate>, Rc<RefCell<BoxedResolver>>, Lrc<LintStore>)>>
+ {
trace!("expansion");
self.expansion.compute(|| {
- let crate_name = *self.crate_name()?.peek();
- let (krate, lint_store) = self.register_plugins()?.take();
+ let crate_name = *self.crate_name()?.borrow();
+ let (krate, lint_store) = self.register_plugins()?.steal();
let _timer = self.session().timer("configure_and_expand");
let sess = self.session();
let mut resolver = passes::create_resolver(
})
}
- fn dep_graph(&self) -> Result<&Query<DepGraph>> {
+ fn dep_graph(&self) -> Result<QueryResult<'_, DepGraph>> {
self.dep_graph.compute(|| {
let sess = self.session();
- let future_opt = self.dep_graph_future()?.take();
+ let future_opt = self.dep_graph_future()?.steal();
let dep_graph = future_opt
.and_then(|future| {
let (prev_graph, prev_work_products) =
})
}
- pub fn prepare_outputs(&self) -> Result<&Query<OutputFilenames>> {
+ pub fn prepare_outputs(&self) -> Result<QueryResult<'_, OutputFilenames>> {
self.prepare_outputs.compute(|| {
- let (krate, boxed_resolver, _) = &*self.expansion()?.peek();
- let crate_name = *self.crate_name()?.peek();
+ let expansion = self.expansion()?;
+ let (krate, boxed_resolver, _) = &*expansion.borrow();
+ let crate_name = *self.crate_name()?.borrow();
passes::prepare_outputs(
self.session(),
self.compiler,
})
}
- pub fn global_ctxt(&'tcx self) -> Result<&Query<QueryContext<'tcx>>> {
+ pub fn global_ctxt(&'tcx self) -> Result<QueryResult<'_, QueryContext<'tcx>>> {
self.global_ctxt.compute(|| {
- let crate_name = *self.crate_name()?.peek();
- let outputs = self.prepare_outputs()?.take();
- let dep_graph = self.dep_graph()?.peek().clone();
- let (krate, resolver, lint_store) = self.expansion()?.take();
+ let crate_name = *self.crate_name()?.borrow();
+ let outputs = self.prepare_outputs()?.steal();
+ let dep_graph = self.dep_graph()?.borrow().clone();
+ let (krate, resolver, lint_store) = self.expansion()?.steal();
Ok(passes::create_global_ctxt(
self.compiler,
lint_store,
})
}
- pub fn ongoing_codegen(&'tcx self) -> Result<&Query<Box<dyn Any>>> {
+ pub fn ongoing_codegen(&'tcx self) -> Result<QueryResult<'_, Box<dyn Any>>> {
self.ongoing_codegen.compute(|| {
- self.global_ctxt()?.peek_mut().enter(|tcx| {
+ self.global_ctxt()?.enter(|tcx| {
tcx.analysis(()).ok();
// Don't do code generation if there were any errors
let sess = self.session().clone();
let codegen_backend = self.codegen_backend().clone();
- let dep_graph = self.dep_graph()?.peek().clone();
- let (crate_hash, prepare_outputs) = self
- .global_ctxt()?
- .peek_mut()
- .enter(|tcx| (tcx.crate_hash(LOCAL_CRATE), tcx.output_filenames(()).clone()));
- let ongoing_codegen = self.ongoing_codegen()?.take();
+ let (crate_hash, prepare_outputs, dep_graph) = self.global_ctxt()?.enter(|tcx| {
+ (tcx.crate_hash(LOCAL_CRATE), tcx.output_filenames(()).clone(), tcx.dep_graph.clone())
+ });
+ let ongoing_codegen = self.ongoing_codegen()?.steal();
Ok(Linker {
sess,
// NOTE: intentionally does not compute the global context if it hasn't been built yet,
// since that likely means there was a parse error.
if let Some(Ok(gcx)) = &mut *queries.global_ctxt.result.borrow_mut() {
+ let gcx = gcx.get_mut();
// We assume that no queries are run past here. If there are new queries
// after this point, they'll show up as "<unknown>" in self-profiling data.
{
projects / rust.git / blobdiff