Remove Option from resolver

Author: Mark-Simulacrum

src/librustc_interface/passes.rs

@@ -58,7 +58,6 @@ use std::path::PathBuf;
 use std::sync::mpsc;
 use std::cell::RefCell;
 use std::rc::Rc;
-use std::mem;
 
 pub fn parse<'a>(sess: &'a Session, input: &Input) -> PResult<'a, ast::Crate> {
     sess.diagnostic()
@@ -204,15 +203,16 @@ impl ExpansionResult {
 
 impl BoxedResolver {
     pub fn to_expansion_result(
-        mut resolver: Rc<Option<RefCell<BoxedResolver>>>,
+        resolver: Rc<RefCell<BoxedResolver>>,
     ) -> ExpansionResult {
-        if let Some(resolver) = Rc::get_mut(&mut resolver) {
-            mem::replace(resolver, None).unwrap().into_inner().complete()
-        } else {
-            let resolver = &*resolver;
-            resolver.as_ref().unwrap().borrow_mut().access(|resolver| {
-                ExpansionResult::from_resolver_ref(resolver)
-            })
+        match Rc::try_unwrap(resolver) {
+            Ok(resolver) => resolver.into_inner().complete(),
+            Err(resolver) => {
+                let resolver = &*resolver;
+                resolver.borrow_mut().access(|resolver| {
+                    ExpansionResult::from_resolver_ref(resolver)
+                })
+            }
         }
     }
 }

src/librustc_interface/queries.rs

@@ -76,7 +76,7 @@ pub(crate) struct Queries {
     parse: Query<ast::Crate>,
     crate_name: Query<String>,
     register_plugins: Query<(ast::Crate, PluginInfo)>,
-    expansion: Query<(ast::Crate, Rc<Option<RefCell<BoxedResolver>>>)>,
+    expansion: Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>)>,
     dep_graph: Query<DepGraph>,
     lower_to_hir: Query<(Steal<hir::map::Forest>, ExpansionResult)>,
     prepare_outputs: Query<OutputFilenames>,
@@ -142,7 +142,7 @@ impl Compiler {
 
     pub fn expansion(
         &self
-    ) -> Result<&Query<(ast::Crate, Rc<Option<RefCell<BoxedResolver>>>)>> {
+    ) -> Result<&Query<(ast::Crate, Steal<Rc<RefCell<BoxedResolver>>>)>> {
         self.queries.expansion.compute(|| {
             let crate_name = self.crate_name()?.peek().clone();
             let (krate, plugin_info) = self.register_plugins()?.take();
@@ -152,7 +152,7 @@ impl Compiler {
                 krate,
                 &crate_name,
                 plugin_info,
-            ).map(|(krate, resolver)| (krate, Rc::new(Some(RefCell::new(resolver)))))
+            ).map(|(krate, resolver)| (krate, Steal::new(Rc::new(RefCell::new(resolver)))))
         })
     }
 
@@ -176,9 +176,10 @@ impl Compiler {
     pub fn lower_to_hir(&self) -> Result<&Query<(Steal<hir::map::Forest>, ExpansionResult)>> {
         self.queries.lower_to_hir.compute(|| {
             let expansion_result = self.expansion()?;
-            let (krate, resolver) = expansion_result.take();
-            let resolver_ref = &*resolver;
-            let hir = Steal::new(resolver_ref.as_ref().unwrap().borrow_mut().access(|resolver| {
+            let peeked = expansion_result.peek();
+            let krate = &peeked.0;
+            let resolver = peeked.1.steal();
+            let hir = Steal::new(resolver.borrow_mut().access(|resolver| {
                 passes::lower_to_hir(
                     self.session(),
                     self.cstore(),
@@ -187,7 +188,6 @@ impl Compiler {
                     &krate
                 )
             })?);
-            expansion_result.give((krate, Rc::new(None)));
             Ok((hir, BoxedResolver::to_expansion_result(resolver)))
         })
     }

src/librustdoc/core.rs

@@ -45,7 +45,7 @@ pub type ExternalPaths = FxHashMap<DefId, (Vec<String>, clean::TypeKind)>;
 pub struct DocContext<'tcx> {
 
     pub tcx: TyCtxt<'tcx>,
-    pub resolver: Rc<Option<RefCell<interface::BoxedResolver>>>,
+    pub resolver: Rc<RefCell<interface::BoxedResolver>>,
     /// The stack of module NodeIds up till this point
     pub crate_name: Option<String>,
     pub cstore: Lrc<CStore>,
@@ -83,9 +83,7 @@ impl<'tcx> DocContext<'tcx> {
 
     pub fn enter_resolver<F, R>(&self, f: F) -> R
     where F: FnOnce(&mut resolve::Resolver<'_>) -> R {
-        let resolver = &*self.resolver;
-        let resolver = resolver.as_ref().unwrap();
-        resolver.borrow_mut().access(f)
+        self.resolver.borrow_mut().access(f)
     }
 
     /// Call the closure with the given parameters set as
@@ -344,7 +342,7 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
         // We need to hold on to the complete resolver, so we cause everything to be
         // cloned for the analysis passes to use. Suboptimal, but necessary in the
         // current architecture.
-        let resolver = abort_on_err(compiler.expansion(), sess).peek().1.clone();
+        let resolver = abort_on_err(compiler.expansion(), sess).peek().1.borrow().clone();
 
         if sess.has_errors() {
             sess.fatal("Compilation failed, aborting rustdoc");