Reduce righward drift.

2 files changed, 160 insertions, 163 deletions

diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs
index b5b331928b9..d9d475813b0 100644
--- a/src/librustdoc/core.rs
+++ b/src/librustdoc/core.rs
@@ -343,153 +343,151 @@ pub fn run_core(options: RustdocOptions) -> (clean::Crate, RenderInfo, RenderOpt
         registry: rustc_driver::diagnostics_registry(),
     };
 
-    interface::run_compiler_in_existing_thread_pool(config, |compiler| {
-        compiler.enter(|queries| {
-            let sess = compiler.session();
-
-            // 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 = {
-                let parts = abort_on_err(queries.expansion(), sess).peek();
-                let resolver = parts.1.borrow();
-
-                // Before we actually clone it, let's force all the extern'd crates to
-                // actually be loaded, just in case they're only referred to inside
-                // intra-doc-links
-                resolver.borrow_mut().access(|resolver| {
-                    for extern_name in &extern_names {
-                        resolver.resolve_str_path_error(
-                            DUMMY_SP, extern_name, TypeNS, CRATE_NODE_ID
-                        ).unwrap_or_else(
-                            |()| panic!("Unable to resolve external crate {}", extern_name)
-                        );
-                    }
-                });
+    interface::run_compiler_in_existing_thread_pool(config, |compiler| { compiler.enter(|queries| {
+        let sess = compiler.session();
+
+        // 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 = {
+            let parts = abort_on_err(queries.expansion(), sess).peek();
+            let resolver = parts.1.borrow();
+
+            // Before we actually clone it, let's force all the extern'd crates to
+            // actually be loaded, just in case they're only referred to inside
+            // intra-doc-links
+            resolver.borrow_mut().access(|resolver| {
+                for extern_name in &extern_names {
+                    resolver.resolve_str_path_error(
+                        DUMMY_SP, extern_name, TypeNS, CRATE_NODE_ID
+                    ).unwrap_or_else(
+                        |()| panic!("Unable to resolve external crate {}", extern_name)
+                    );
+                }
+            });
+
+            // Now we're good to clone the resolver because everything should be loaded
+            resolver.clone()
+        };
+
+        if sess.has_errors() {
+            sess.fatal("Compilation failed, aborting rustdoc");
+        }
+
+        let mut global_ctxt = abort_on_err(queries.global_ctxt(), sess).take();
 
-                // Now we're good to clone the resolver because everything should be loaded
-                resolver.clone()
+        global_ctxt.enter(|tcx| {
+            tcx.analysis(LOCAL_CRATE).ok();
+
+            // Abort if there were any errors so far
+            sess.abort_if_errors();
+
+            let access_levels = tcx.privacy_access_levels(LOCAL_CRATE);
+            // Convert from a HirId set to a DefId set since we don't always have easy access
+            // to the map from defid -> hirid
+            let access_levels = AccessLevels {
+                map: access_levels.map.iter()
+                                    .map(|(&k, &v)| (tcx.hir().local_def_id(k), v))
+                                    .collect()
             };
 
-            if sess.has_errors() {
-                sess.fatal("Compilation failed, aborting rustdoc");
-            }
+            let mut renderinfo = RenderInfo::default();
+            renderinfo.access_levels = access_levels;
+
+            let mut ctxt = DocContext {
+                tcx,
+                resolver,
+                external_traits: Default::default(),
+                active_extern_traits: Default::default(),
+                renderinfo: RefCell::new(renderinfo),
+                ty_substs: Default::default(),
+                lt_substs: Default::default(),
+                ct_substs: Default::default(),
+                impl_trait_bounds: Default::default(),
+                fake_def_ids: Default::default(),
+                all_fake_def_ids: Default::default(),
+                generated_synthetics: Default::default(),
+                auto_traits: tcx.all_traits(LOCAL_CRATE).iter().cloned().filter(|trait_def_id| {
+                    tcx.trait_is_auto(*trait_def_id)
+                }).collect(),
+            };
+            debug!("crate: {:?}", tcx.hir().krate());
 
-            let mut global_ctxt = abort_on_err(queries.global_ctxt(), sess).take();
-
-            global_ctxt.enter(|tcx| {
-                tcx.analysis(LOCAL_CRATE).ok();
-
-                // Abort if there were any errors so far
-                sess.abort_if_errors();
-
-                let access_levels = tcx.privacy_access_levels(LOCAL_CRATE);
-                // Convert from a HirId set to a DefId set since we don't always have easy access
-                // to the map from defid -> hirid
-                let access_levels = AccessLevels {
-                    map: access_levels.map.iter()
-                                        .map(|(&k, &v)| (tcx.hir().local_def_id(k), v))
-                                        .collect()
-                };
-
-                let mut renderinfo = RenderInfo::default();
-                renderinfo.access_levels = access_levels;
-
-                let mut ctxt = DocContext {
-                    tcx,
-                    resolver,
-                    external_traits: Default::default(),
-                    active_extern_traits: Default::default(),
-                    renderinfo: RefCell::new(renderinfo),
-                    ty_substs: Default::default(),
-                    lt_substs: Default::default(),
-                    ct_substs: Default::default(),
-                    impl_trait_bounds: Default::default(),
-                    fake_def_ids: Default::default(),
-                    all_fake_def_ids: Default::default(),
-                    generated_synthetics: Default::default(),
-                    auto_traits: tcx.all_traits(LOCAL_CRATE).iter().cloned().filter(|trait_def_id| {
-                        tcx.trait_is_auto(*trait_def_id)
-                    }).collect(),
-                };
-                debug!("crate: {:?}", tcx.hir().krate());
-
-                let mut krate = clean::krate(&mut ctxt);
-
-                fn report_deprecated_attr(name: &str, diag: &errors::Handler) {
-                    let mut msg = diag.struct_warn(&format!("the `#![doc({})]` attribute is \
-                                                             considered deprecated", name));
-                    msg.warn("please see https://github.com/rust-lang/rust/issues/44136");
-
-                    if name == "no_default_passes" {
-                        msg.help("you may want to use `#![doc(document_private_items)]`");
-                    }
+            let mut krate = clean::krate(&mut ctxt);
+
+            fn report_deprecated_attr(name: &str, diag: &errors::Handler) {
+                let mut msg = diag.struct_warn(&format!("the `#![doc({})]` attribute is \
+                                                         considered deprecated", name));
+                msg.warn("please see https://github.com/rust-lang/rust/issues/44136");
 
-                    msg.emit();
+                if name == "no_default_passes" {
+                    msg.help("you may want to use `#![doc(document_private_items)]`");
                 }
 
-                // Process all of the crate attributes, extracting plugin metadata along
-                // with the passes which we are supposed to run.
-                for attr in krate.module.as_ref().unwrap().attrs.lists(sym::doc) {
-                    let diag = ctxt.sess().diagnostic();
-
-                    let name = attr.name_or_empty();
-                    if attr.is_word() {
-                        if name == sym::no_default_passes {
-                            report_deprecated_attr("no_default_passes", diag);
-                            if default_passes == passes::DefaultPassOption::Default {
-                                default_passes = passes::DefaultPassOption::None;
-                            }
-                        }
-                    } else if let Some(value) = attr.value_str() {
-                        let sink = match name {
-                            sym::passes => {
-                                report_deprecated_attr("passes = \"...\"", diag);
-                                &mut manual_passes
-                            },
-                            sym::plugins => {
-                                report_deprecated_attr("plugins = \"...\"", diag);
-                                eprintln!("WARNING: `#![doc(plugins = \"...\")]` \
-                                          no longer functions; see CVE-2018-1000622");
-                                continue
-                            },
-                            _ => continue,
-                        };
-                        for name in value.as_str().split_whitespace() {
-                            sink.push(name.to_string());
-                        }
-                    }
+                msg.emit();
+            }
+
+            // Process all of the crate attributes, extracting plugin metadata along
+            // with the passes which we are supposed to run.
+            for attr in krate.module.as_ref().unwrap().attrs.lists(sym::doc) {
+                let diag = ctxt.sess().diagnostic();
 
-                    if attr.is_word() && name == sym::document_private_items {
+                let name = attr.name_or_empty();
+                if attr.is_word() {
+                    if name == sym::no_default_passes {
+                        report_deprecated_attr("no_default_passes", diag);
                         if default_passes == passes::DefaultPassOption::Default {
-                            default_passes = passes::DefaultPassOption::Private;
+                            default_passes = passes::DefaultPassOption::None;
                         }
                     }
+                } else if let Some(value) = attr.value_str() {
+                    let sink = match name {
+                        sym::passes => {
+                            report_deprecated_attr("passes = \"...\"", diag);
+                            &mut manual_passes
+                        },
+                        sym::plugins => {
+                            report_deprecated_attr("plugins = \"...\"", diag);
+                            eprintln!("WARNING: `#![doc(plugins = \"...\")]` \
+                                      no longer functions; see CVE-2018-1000622");
+                            continue
+                        },
+                        _ => continue,
+                    };
+                    for name in value.as_str().split_whitespace() {
+                        sink.push(name.to_string());
+                    }
                 }
 
-                let passes = passes::defaults(default_passes).iter().chain(manual_passes.into_iter()
-                    .flat_map(|name| {
-                        if let Some(pass) = passes::find_pass(&name) {
-                            Some(pass)
-                        } else {
-                            error!("unknown pass {}, skipping", name);
-                            None
-                        }
-                    }));
+                if attr.is_word() && name == sym::document_private_items {
+                    if default_passes == passes::DefaultPassOption::Default {
+                        default_passes = passes::DefaultPassOption::Private;
+                    }
+                }
+            }
+
+            let passes = passes::defaults(default_passes).iter().chain(manual_passes.into_iter()
+                .flat_map(|name| {
+                    if let Some(pass) = passes::find_pass(&name) {
+                        Some(pass)
+                    } else {
+                        error!("unknown pass {}, skipping", name);
+                        None
+                    }
+                }));
 
-                info!("Executing passes");
+            info!("Executing passes");
 
-                for pass in passes {
-                    debug!("running pass {}", pass.name);
-                    krate = (pass.pass)(krate, &ctxt);
-                }
+            for pass in passes {
+                debug!("running pass {}", pass.name);
+                krate = (pass.pass)(krate, &ctxt);
+            }
 
-                ctxt.sess().abort_if_errors();
+            ctxt.sess().abort_if_errors();
 
-                (krate, ctxt.renderinfo.into_inner(), render_options)
-            })
+            (krate, ctxt.renderinfo.into_inner(), render_options)
         })
-    })
+    }) })
 }
 
 /// `DefId` or parameter index (`ty::ParamTy.index`) of a synthetic type parameter
diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs
index 47eb993dfc3..4cb97ccb0bf 100644
--- a/src/librustdoc/test.rs
+++ b/src/librustdoc/test.rs
@@ -85,42 +85,41 @@ pub fn run(options: Options) -> i32 {
     let mut test_args = options.test_args.clone();
     let display_warnings = options.display_warnings;
 
-    let tests = interface::run_compiler(config, |compiler| -> Result<_, ErrorReported> {
-        compiler.enter(|queries| {
-            let lower_to_hir = queries.lower_to_hir()?;
-
-            let mut opts = scrape_test_config(lower_to_hir.peek().0.borrow().krate());
-            opts.display_warnings |= options.display_warnings;
-            let enable_per_target_ignores = options.enable_per_target_ignores;
-            let mut collector = Collector::new(
-                queries.crate_name()?.peek().to_string(),
-                options,
-                false,
-                opts,
-                Some(compiler.source_map().clone()),
-                None,
-                enable_per_target_ignores,
-            );
-
-            let mut global_ctxt = queries.global_ctxt()?.take();
-
-            global_ctxt.enter(|tcx| {
-                let krate = tcx.hir().krate();
-                let mut hir_collector = HirCollector {
-                    sess: compiler.session(),
-                    collector: &mut collector,
-                    map: tcx.hir(),
-                    codes: ErrorCodes::from(compiler.session().opts
-                                                    .unstable_features.is_nightly_build()),
-                };
-                hir_collector.visit_testable("".to_string(), &krate.attrs, |this| {
-                    intravisit::walk_crate(this, krate);
-                });
+    let tests = interface::run_compiler(config, |compiler| { compiler.enter(|queries| {
+        let lower_to_hir = queries.lower_to_hir()?;
+
+        let mut opts = scrape_test_config(lower_to_hir.peek().0.borrow().krate());
+        opts.display_warnings |= options.display_warnings;
+        let enable_per_target_ignores = options.enable_per_target_ignores;
+        let mut collector = Collector::new(
+            queries.crate_name()?.peek().to_string(),
+            options,
+            false,
+            opts,
+            Some(compiler.source_map().clone()),
+            None,
+            enable_per_target_ignores,
+        );
+
+        let mut global_ctxt = queries.global_ctxt()?.take();
+
+        global_ctxt.enter(|tcx| {
+            let krate = tcx.hir().krate();
+            let mut hir_collector = HirCollector {
+                sess: compiler.session(),
+                collector: &mut collector,
+                map: tcx.hir(),
+                codes: ErrorCodes::from(compiler.session().opts
+                                                .unstable_features.is_nightly_build()),
+            };
+            hir_collector.visit_testable("".to_string(), &krate.attrs, |this| {
+                intravisit::walk_crate(this, krate);
             });
+        });
 
-            Ok(collector.tests)
-        })
-    }).expect("compiler aborted in rustdoc!");
+        let ret : Result<_, ErrorReported> = Ok(collector.tests);
+        ret
+    }) }).expect("compiler aborted in rustdoc!");
 
     test_args.insert(0, "rustdoctest".to_string());