fix some tests lolzzzzz

Author: jyn514

src/librustdoc/clean/mod.rs

@@ -1890,6 +1890,7 @@ fn clean_maybe_renamed_item(
 ) -> Vec<Item> {
     use hir::ItemKind;
 
+    debug!("clean HIR item {:?}", item);
     let def_id = item.def_id.to_def_id();
     let mut name = renamed.unwrap_or_else(|| cx.tcx.hir().name(item.hir_id()));
     cx.with_param_env(def_id, |cx| {
@@ -2017,6 +2018,7 @@ fn clean_impl(impl_: &hir::Impl<'_>, hir_id: hir::HirId, cx: &mut DocContext<'_>
         ret.push(make_item(trait_.clone(), type_alias, items.clone()));
     }
     ret.push(make_item(trait_, for_, items));
+    debug!("create cleaned impl item {:?}", ret);
     ret
 }
 

src/librustdoc/clean/types.rs

@@ -1123,11 +1123,16 @@ impl Attributes {
                         ast::LitKind::Str(s, _) => {
                             aliases.insert(s);
                         }
-                        _ => unreachable!(),
+                        // This can be reached in case of an invalid attribute.
+                        // We test that rustc_passes gives an error in `src/test/rustdoc-ui/check-doc-alias-attr.rs`
+                        _ => {}
                     }
                 }
-            } else {
-                aliases.insert(attr.value_str().unwrap());
+            // This can be None if the user specified an invalid attribute, e.g. `doc(alias = 0)`.
+            // The error will be caught by rustc_passes, but we still need to handle it here because
+            // the Cache is populated before calling `abort_if_err()`.
+            } else if let Some(value) = attr.value_str() {
+                aliases.insert(value);
             }
         }
         aliases.into_iter().collect::<Vec<_>>().into()

src/librustdoc/core.rs

@@ -457,13 +457,15 @@ crate fn run_global_ctxt(
     for &p in passes_before_cache {
         krate = run_pass(p, krate, &mut ctxt);
     }
-    ctxt.sess().abort_if_errors();
 
     krate = tcx.sess.time("create_format_cache", || Cache::populate(&mut ctxt, krate));
     for &p in passes_after_cache {
         krate = run_pass(p, krate, &mut ctxt);
     }
-    ctxt.sess().abort_if_errors();
+
+    if tcx.sess.diagnostic().has_errors_or_lint_errors().is_some() {
+        rustc_errors::FatalError.raise();
+    }
 
     (krate, ctxt.render_options, ctxt.cache)
 }

src/librustdoc/formats/cache.rs

@@ -210,6 +210,7 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
                     .def_id(self.cache)
                     .map_or(false, |d| self.cache.masked_crates.contains(&d.krate))
             {
+                debug!("remove masked impl {:?}", i);
                 return None;
             }
         }
@@ -461,16 +462,17 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> {
                     }
                 }
             }
-            let impl_item = Impl { impl_item: item };
+            let impl_item = Impl { impl_item: item.clone() };
             if impl_item.trait_did().map_or(true, |d| self.cache.traits.contains_key(&d)) {
                 for did in dids {
                     self.cache.impls.entry(did).or_insert_with(Vec::new).push(impl_item.clone());
                 }
             } else {
                 let trait_did = impl_item.trait_did().expect("no trait did");
-                self.cache.orphan_trait_impls.push((trait_did, dids, impl_item));
+                self.cache.orphan_trait_impls.push((trait_did, dids, impl_item.clone()));
             }
-            None
+            // TODO: stripping this from `Module` seems ... not great
+            Some(impl_item.impl_item)
         } else {
             Some(item)
         };

src/librustdoc/passes/collect_intra_doc_links.rs

@@ -41,6 +41,7 @@ crate const COLLECT_INTRA_DOC_LINKS: Pass = Pass {
 };
 
 fn collect_intra_doc_links(krate: Crate, cx: &mut DocContext<'_>) -> Crate {
+    debug!("logging works");
     let mut collector =
         LinkCollector { cx, mod_ids: Vec::new(), visited_links: FxHashMap::default() };
     collector.visit_crate(&krate);
@@ -2344,8 +2345,9 @@ fn missing_docs_for_link(
             return;
         }
 
-        // shouldn't be possible to resolve private items
-        assert_ne!(why, HrefError::Private, "{:?}", destination_id);
+        // NOTE: theoretically it shouldn't be possible to resolve private items,
+        // but `resolve_primitive_associated_item` is buggy and allows it.
+        // assert_ne!(why, HrefError::Private, "{:?}", destination_id);
 
         if let Some(attr) =
             cx.tcx.get_attrs(destination_id).lists(sym::doc).get_word_attr(sym::hidden)

src/librustdoc/passes/mod.rs

@@ -98,6 +98,7 @@ crate const DEFAULT_PASSES: (&[ConditionalPass], &[ConditionalPass]) = (
     &[
         ConditionalPass::always(COLLECT_TRAIT_IMPLS),
         ConditionalPass::always(UNINDENT_COMMENTS),
+        ConditionalPass::always(CHECK_DOC_TEST_VISIBILITY),
         ConditionalPass::new(STRIP_HIDDEN, WhenNotDocumentHidden),
         ConditionalPass::new(STRIP_PRIVATE, WhenNotDocumentPrivate),
         ConditionalPass::new(STRIP_PRIV_IMPORTS, WhenDocumentPrivate),

src/librustdoc/visit.rs

@@ -55,7 +55,12 @@ crate trait DocVisitor: Sized {
     }
 
     fn visit_mod(&mut self, m: &Module) {
-        m.items.iter().for_each(|i| self.visit_item(i))
+        m.items.iter().for_each(|i| self.visit_item(i));
+        // for i in self.cache.impls {
+        //     if m.def_id() == find_nearest_parent_module(self.tcx, i.def_id) {
+        //         self.visit_item(i);
+        //     }
+        // }
     }
 
     fn visit_crate(&mut self, c: &Crate) {

src/librustdoc/visit_ast.rs

@@ -161,6 +161,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
         self.inside_public_path &= self.cx.tcx.visibility(def_id).is_public();
         for &i in m.item_ids {
             let item = self.cx.tcx.hir().item(i);
+            debug!("{:?}", item);
             self.visit_item(item, None, &mut om);
         }
         self.inside_public_path = orig_inside_public_path;
@@ -368,7 +369,9 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> {
             hir::ItemKind::Impl(ref impl_) => {
                 // Don't duplicate impls when inlining or if it's implementing a trait, we'll pick
                 // them up regardless of where they're located.
+                debug!("handle impl block");
                 if !self.inlining && impl_.of_trait.is_none() {
+                    debug!("propagate impl block");
                     om.items.push((item, None));
                 }
             }

src/test/rustdoc-ui/intra-doc/extern-crate-load.rs

@@ -4,6 +4,7 @@
 // aux-crate:dep3=dep3.rs
 // aux-crate:dep4=dep4.rs
 #![deny(rustdoc::broken_intra_doc_links)]
+#![allow(rustdoc::private_intra_doc_links)]
 
 pub trait Trait {
     /// [dep1]

src/test/rustdoc-ui/intra-doc/feature-gate-intra-doc-pointers.rs

@@ -1,6 +1,8 @@
 //! [pointer::add]
 //~^ ERROR: experimental
+//~| WARNING will not have documentation generated
 //! [pointer::wrapping_add]
 //~^ ERROR: experimental
+//~| WARNING will not have documentation generated
 //! [pointer] // This is explicitly allowed
 //! [reference] // This is explicitly allowed