themePicker.onblur = handleThemeButtonsBlur;     // with rustdoc running in parallel.     all_indexes.sort();     {-        let mut v = String::from("var searchIndex = JSON.parse('{\\\n");+        let mut v = String::from("var searchIndex = JSON.parse(\"{\\n");         v.push_str(&all_indexes.join(",\\\n"));         // "addSearchOptions" has to be called first so the crate filtering can be set before the         // search might start (if it's set into the URL for example).-        v.push_str("\\\n}');\naddSearchOptions(searchIndex);initSearch(searchIndex);");+        v.push_str("\\\n}\");\naddSearchOptions(searchIndex);initSearch(searchIndex);");

 themePicker.onblur = handleThemeButtonsBlur;     // with rustdoc running in parallel.     all_indexes.sort();     {-        let mut v = String::from("var searchIndex = JSON.parse('{\\\n");+        let mut v = String::from("var searchIndex = JSON.parse(\"{\\n");

 function handleThemeButtonsBlur(e) {{ themePicker.onclick = switchThemeButtonState; themePicker.onblur = handleThemeButtonsBlur; {}.forEach(function(item) {{-    var but = document.createElement('button');+    var but = document.createElement(\"button\");

 warning: unclosed HTML tag `h1`  warning: 2 warnings emitted ```++## automatic_links++This lint is **nightly-only** and **warns by default**. It detects links which+could use the "automatic" link syntax. For example:++```rust+/// http://hello.rs+/// [http://a.com](http://a.com)+/// [http://b.com]+///+/// [http://b.com]: http://b.com

 fn merge_attrs(     // doc comments show up before the original doc comments     // when we render them.     if let Some(inner) = new_attrs {-        if let Some(new_id) = parent_module {-            let diag = cx.sess().diagnostic();-            Attributes::from_ast(diag, old_attrs, Some((inner, new_id)))-        } else {-            let mut both = inner.to_vec();-            both.extend_from_slice(old_attrs);-            both.clean(cx)+        if !inner.is_empty() {

 mod perf_counter {     }      fn frequency() -> c::LARGE_INTEGER {-        static mut FREQUENCY: c::LARGE_INTEGER = 0;-        static STATE: AtomicUsize = AtomicUsize::new(0);-+        // Either the cached result of `QueryPerformanceFrequency` or `0` for+        // uninitialized. Storing this as a single `AtomicU64` allows us to use+        // `Relaxed` operations, as we are only interested in the effects on a+        // single memory location.+        static FREQUENCY: AtomicU64 = AtomicU64::new(0);

 fn extract_tag( ) {     let mut iter = text.chars().enumerate().peekable(); -    while let Some((start_pos, c)) = iter.next() {+    'top: while let Some((start_pos, c)) = iter.next() {         if c == '<' {             let mut tag_name = String::new();             let mut is_closing = false;-            while let Some((pos, c)) = iter.peek() {+            let mut prev_pos = start_pos;+            loop {+                let (pos, c) = match iter.peek() {+                    Some((pos, c)) => (*pos, *c),+                    // In case we reached the of the doc comment, we want to check that it's an+                    // unclosed HTML tag. For example "/// <h3".+                    None => (prev_pos, '\0'),+                };+                prev_pos = pos;                 // Checking if this is a closing tag (like `</a>` for `<a>`).-                if *c == '/' && tag_name.is_empty() {+                if c == '/' && tag_name.is_empty() {                     is_closing = true;-                } else if c.is_ascii_alphanumeric() && !c.is_ascii_uppercase() {-                    tag_name.push(*c);+                } else if c.is_ascii_alphanumeric() {+                    tag_name.push(c);

 pub struct UnixToken; Here, the respective tokens can only be used by dependent crates on their respective platforms, but they will both appear in documentation. +### Interactions between platform-specific docs++Rustdoc does not have a magic way to compile documentation 'as-if' you'd run it once for each+platform (such a magic wand has been called the ['holy grail of rustdoc'][#1998]). Instead,+it sees *all* of your code at once, the same way the Rust compiler would if you passed it+`--cfg doc`. However, Rustdoc has a trick up its sleeve to handle platform-specific code if it+*does* receive it.++To document your crate, Rustdoc only needs to know the public signature of your functions.+In particular, it doesn't have know how any of your functions are implemented, so it ignores

 impl Clean<Vec<Item>> for doctree::ExternCrate<'_> {  impl Clean<Vec<Item>> for doctree::Import<'_> {     fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {+        // We need this comparison because some imports (for std types for example)+        // are "inserted" as well but directly by the compiler and they should not be+        // taken into account.+        if self.span.is_dummy() {+            return Vec::new();+        }

 impl Clean<Vec<Item>> for doctree::ExternCrate<'_> {  impl Clean<Vec<Item>> for doctree::Import<'_> {     fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {+        // We need this comparison because some imports (for std types for example)+        // are "inserted" as well but directly by the compiler and they should not be+        // taken into account.+        if self.span.is_dummy() {+            return Vec::new();+        }

 fn extract_tag( ) {     let mut iter = text.chars().enumerate().peekable(); -    while let Some((start_pos, c)) = iter.next() {+    'top: while let Some((start_pos, c)) = iter.next() {         if c == '<' {             let mut tag_name = String::new();             let mut is_closing = false;-            while let Some((pos, c)) = iter.peek() {+            let mut prev_pos = start_pos;+            loop {+                let (pos, c) = match iter.peek() {+                    Some((pos, c)) => (*pos, *c),+                    // In case we reached the of the doc comment, we want to check that it's an+                    // unclosed HTML tag. For example "/// <h3".+                    None => (prev_pos, '\0'),+                };+                prev_pos = pos;                 // Checking if this is a closing tag (like `</a>` for `<a>`).-                if *c == '/' && tag_name.is_empty() {+                if c == '/' && tag_name.is_empty() {                     is_closing = true;-                } else if c.is_ascii_alphanumeric() && !c.is_ascii_uppercase() {-                    tag_name.push(*c);+                } else if c.is_ascii_alphanumeric() {+                    tag_name.push(c);

+use super::{span_of_attrs, Pass};+use crate::clean::*;+use crate::core::DocContext;+use crate::fold::DocFolder;+use crate::html::markdown::opts;+use core::ops::Range;+use pulldown_cmark::{Event, Parser};+use rustc_feature::UnstableFeatures;+use rustc_session::lint;++pub const CHECK_INVALID_HTML_TAGS: Pass = Pass {+    name: "check-invalid-html-tags",+    run: check_invalid_html_tags,+    description: "detects invalid HTML tags in doc comments",+};++struct InvalidHtmlTagsLinter<'a, 'tcx> {+    cx: &'a DocContext<'tcx>,+}++impl<'a, 'tcx> InvalidHtmlTagsLinter<'a, 'tcx> {+    fn new(cx: &'a DocContext<'tcx>) -> Self {+        InvalidHtmlTagsLinter { cx }+    }+}++pub fn check_invalid_html_tags(krate: Crate, cx: &DocContext<'_>) -> Crate {+    if !UnstableFeatures::from_environment().is_nightly_build() {+        krate+    } else {+        let mut coll = InvalidHtmlTagsLinter::new(cx);++        coll.fold_crate(krate)+    }+}++const ALLOWED_UNCLOSED: &[&str] = &[+    "area", "base", "br", "col", "embed", "hr", "img", "input", "keygen", "link", "meta", "param",+    "source", "track", "wbr",+];++fn drop_tag(+    tags: &mut Vec<(String, Range<usize>)>,+    tag_name: String,+    range: Range<usize>,+    f: &impl Fn(&str, &Range<usize>),+) {+    let tag_name_low = tag_name.to_lowercase();+    if let Some(pos) = tags.iter().rev().position(|(t, _)| t.to_lowercase() == tag_name_low) {+        // Because this is from a `rev` iterator, the position is reversed as well!+        let pos = tags.len() - 1 - pos;+        // If the tag is nested inside a "<script>" or a "<style>" tag, no warning should+        // be emitted.+        let should_not_warn = tags.iter().take(pos + 1).any(|(at, _)| {+            let at = at.to_lowercase();+            at == "script" || at == "style"+        });+        for (last_tag_name, last_tag_span) in tags.drain(pos + 1..) {+            if should_not_warn {+                continue;+            }+            let last_tag_name_low = last_tag_name.to_lowercase();+            if ALLOWED_UNCLOSED.iter().any(|&at| at == &last_tag_name_low) {+                continue;+            }+            // `tags` is used as a queue, meaning that everything after `pos` is included inside it.+            // So `<h2><h3></h2>` will look like `["h2", "h3"]`. So when closing `h2`, we will still+            // have `h3`, meaning the tag wasn't closed as it should have.+            f(&format!("unclosed HTML tag `{}`", last_tag_name), &last_tag_span);+        }+        // Remove the `tag_name` that was originally closed+        tags.pop();+    } else {+        // It can happen for example in this case: `<h2></script></h2>` (the `h2` tag isn't required+        // but it helps for the visualization).+        f(&format!("unopened HTML tag `{}`", tag_name), &range);+    }+}++fn extract_tag(+    tags: &mut Vec<(String, Range<usize>)>,+    text: &str,+    range: Range<usize>,+    f: &impl Fn(&str, &Range<usize>),+) {+    let mut iter = text.chars().enumerate().peekable();

 fn drop_tag(     range: Range<usize>,     f: &impl Fn(&str, &Range<usize>), ) {-    if let Some(pos) = tags.iter().rev().position(|(t, _)| *t == tag_name) {+    let tag_name_low = tag_name.to_lowercase();+    if let Some(pos) = tags.iter().rev().position(|(t, _)| t.to_lowercase() == tag_name_low) {         // Because this is from a `rev` iterator, the position is reversed as well!

+#![allow(invalid_html_tags)]

  // ignore-tidy-linelength -// Crate-level is accepted, though it is almost certainly unused?+#![deny(unused_attributes)]+//~^ NOTE not a function or static+//~^^ NOTE the lint level is defined here+//~^^^ NOTE not an `extern crate` item+//~^^^^ NOTE not a function or static+//~^^^^^ NOTE not a function or closure++#![macro_export]+#![main]+#![start]+#![repr()]+#![path = "3800"]+#![automatically_derived]

  // ignore-tidy-linelength -// Crate-level is accepted, though it is almost certainly unused?+#![deny(unused_attributes)]+//~^ NOTE not a function or static+//~^^ NOTE the lint level is defined here+//~^^^ NOTE not an `extern crate` item+//~^^^^ NOTE not a function or static+//~^^^^^ NOTE not a function or closure++#![macro_export]+#![main]+#![start]+#![repr()]+#![path = "3800"]+#![automatically_derived]

  // ignore-tidy-linelength -// Crate-level is accepted, though it is almost certainly unused?+#![deny(unused_attributes)]

 LL | | LL | | }    | |_- not a function or static +error: attribute should be applied to a function or static+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:23:1+   |+LL | / #![deny(unused_attributes)]+LL | |+LL | |+LL | |+...  |+LL | | #![no_mangle]+   | | ^^^^^^^^^^^^^+...  |+LL | |+LL | | fn main() {}+   | |____________- not a function or static

 #![forbid(x5200)] //~ WARN unknown lint: `x5200` #![deny(x5100)] //~ WARN unknown lint: `x5100` #![macro_use] // (allowed if no argument; see issue-43160-gating-of-macro_use.rs)-#![macro_export] //~ WARN unused attribute // skipping testing of cfg // skipping testing of cfg_attr-#![main] //~ WARN unused attribute-#![start] //~ WARN unused attribute-// see issue-43106-gating-of-test.rs for crate-level; but non crate-level is below at "4200"-// see issue-43106-gating-of-bench.rs for crate-level; but non crate-level is below at "4100"-#![repr()]-//~^ WARN unused attribute-#![path = "3800"] //~ WARN unused attribute-#![automatically_derived] //~ WARN unused attribute-#![no_mangle]-#![no_link] //~ WARN unused attribute

  // ignore-tidy-linelength -// Crate-level is accepted, though it is almost certainly unused?-#![inline]

 impl Clean<Vec<Item>> for doctree::Import<'_> {         let inner = if self.glob {             if !denied {                 let mut visited = FxHashSet::default();-                if let Some(items) = inline::try_inline_glob(cx, path.res, &mut visited) {+                if let Some(mut items) = inline::try_inline_glob(cx, path.res, &mut visited) {+                    items.push(Item {+                        name: None,+                        attrs: self.attrs.clean(cx),+                        source: self.span.clean(cx),+                        def_id: cx.tcx.hir().local_def_id(self.id).to_def_id(),+                        visibility: self.vis.clean(cx),+                        stability: None,+                        deprecation: None,+                        inner: ImportItem(Import::new_glob(resolve_use_source(cx, path), false)),+                    });

 impl Clean<Vec<Item>> for doctree::ExternCrate<'_> {  impl Clean<Vec<Item>> for doctree::Import<'_> {     fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {+        // We need this comparison because some imports (for std types for example)+        // are "inserted" as well but directly by the compiler and they should not be+        // taken into account.+        if self.span.is_dummy() {+            return Vec::new();+        }

 impl Clean<Vec<Item>> for doctree::ExternCrate<'_> {  impl Clean<Vec<Item>> for doctree::Import<'_> {     fn clean(&self, cx: &DocContext<'_>) -> Vec<Item> {+        // We need this comparison because some imports (for std types for example)+        // are "inserted" as well but directly by the compiler and they should not be+        // taken into account.+        if self.span.is_dummy() {+            return Vec::new();+        }

 fn item_module(w: &mut Buffer, cx: &Context, item: &clean::Item, items: &[clean:             }              clean::ImportItem(ref import) => {-                write!(-                    w,-                    "<tr><td><code>{}{}</code></td></tr>",-                    myitem.visibility.print_with_space(),-                    import.print()-                );+                if import.should_be_displayed {

 impl<K: Ord, V> BTreeMap<K, V> {     /// types that can be `==` without being identical. See the [module-level     /// documentation] for more.     ///-    /// [module-level documentation]: crate::collections#insert-and-complex-keys+    /// [module-level documentation]: index.html#insert-and-complex-keys

 impl<K: Ord, V> BTreeMap<K, V> {     /// types that can be `==` without being identical. See the [module-level     /// documentation] for more.     ///-    /// [module-level documentation]: crate::collections#insert-and-complex-keys+    /// [module-level documentation]: index.html#insert-and-complex-keys

 pub struct UnixToken; Here, the respective tokens can only be used by dependent crates on their respective platforms, but they will both appear in documentation. +### Interactions between platform-specific docs++Rustdoc does not have a magic way to compile documentation 'as-if' you'd run it once for each+platform (such a magic wand has been called the ['holy grail of rustdoc'][#1998]). Instead,+it sees *all* of your code at once, the same way the Rust compiler would if you passed it+`--cfg doc`. However, Rustdoc has a trick up its sleeve to handle platform-specific code if it+*does* receive it.++To document your crate, Rustdoc only needs to know the public signature of your functions.+In particular, it doesn't have know how any of your functions are implemented, so it ignores+all type errors and name resolution errors with function bodies. Note that this does *not*+work for anything outside a function body: since Rustdoc documents your types, it has to+know what those types are! For example, this code will work regardless of the platform:++<!-- `ignore` because doc-tests are run with `rustc`, not `rustdoc` -->+```ignore+pub fn f() {+	use std::os::windows::ffi::OsStrExt;+}+```++but this will not, because the unknown type is part of the function signature:++```compile_fail+pub fn f() -> std::os::windows::ffi::EncodeWide {

 pub struct UnixToken; Here, the respective tokens can only be used by dependent crates on their respective platforms, but they will both appear in documentation. +### Interactions between platform-specific docs++Rustdoc does not have a magic way to compile documentation 'as-if' you'd run it once for each+platform (such a magic wand has been called the ['holy grail of rustdoc'][#1998]). Instead,+it sees *all* of your code at once, the same way the Rust compiler would if you passed it+`--cfg doc`. However, Rustdoc has a trick up its sleeve to handle platform-specific code if it+*does* receive it.++To document your crate, Rustdoc only needs to know the public signature of your functions.+In particular, it doesn't have know how any of your functions are implemented, so it ignores+all type errors and name resolution errors with function bodies. Note that this does *not*+work for anything outside a function body: since Rustdoc documents your types, it has to+know what those types are! For example, this code will work regardless of the platform:++<!-- `ignore` because doc-tests are run with `rustc`, not `rustdoc` -->+```ignore+pub fn f() {+	use std::os::windows::ffi::OsStrExt;

 pub struct UnixToken; Here, the respective tokens can only be used by dependent crates on their respective platforms, but they will both appear in documentation. +### Interactions between platform-specific docs++Rustdoc does not have a magic way to compile documentation 'as-if' you'd run it once for each+platform (such a magic wand has been called the ['holy grail of rustdoc'][#1998]). Instead,+it sees *all* of your code at once, the same way the Rust compiler would if you passed it+`--cfg doc`. However, Rustdoc has a trick up its sleeve to handle platform-specific code if it+*does* receive it.++To document your crate, Rustdoc only needs to know the public signature of your functions.+In particular, it doesn't have know how any of your functions are implemented, so it ignores+all type errors and name resolution errors with function bodies. Note that this does *not*+work for anything outside a function body: since Rustdoc documents your types, it has to+know what those types are! For example, this code will work regardless of the platform:++<!-- `ignore` because doc-tests are run with `rustc`, not `rustdoc` -->+```ignore+pub fn f() {+	use std::os::windows::ffi::OsStrExt;+}+```++but this will not, because the unknown type is part of the function signature:++```compile_fail+pub fn f() -> std::os::windows::ffi::EncodeWide {+	unimplemented!()

 Note: Because of how `macro_rules` macros are scoped in Rust, the intra-doc link These features operate by extending the `#[doc]` attribute, and thus can be caught by the compiler and enabled with a `#![feature(...)]` attribute in your crate. -### Documenting platform-/feature-specific information+### `#[doc(cfg)]`: Telling rustdoc what platforms documentation is present on

 mod prim_char {} #[stable(feature = "rust1", since = "1.0.0")] mod prim_unit {} +#[doc(alias = "ptr")]+#[doc(alias = "pointer")]

 pub fn look_for_tests<'tcx>(cx: &DocContext<'tcx>, dox: &str, item: &Item) {      find_testable_code(&dox, &mut tests, ErrorCodes::No, false, None); +    if cx.render_options.document_private+        && dox.is_empty()+        && !matches!(item.inner, clean::ImportItem(..))+    {+        let sp = span_of_attrs(&item.attrs).unwrap_or(item.source.span());+        if !sp.is_dummy() {+            cx.tcx.struct_span_lint_hir(rustc_lint::builtin::MISSING_DOCS, hir_id, sp, |lint| {+                lint.build("missing documentation").emit()+            });+        }+    }

 macro_rules! vec { /// format!("hello {}", "world!"); /// format!("x = {}, y = {y}", 10, y = 30); /// ```+#[allow_internal_unstable(display_type_guard)] #[macro_export] #[stable(feature = "rust1", since = "1.0.0")] macro_rules! format {+    // A faster path for simple format! calls.+    ("{}", $($arg:tt,?)+) => {{

 fn is_c_like_enum(item: &Item<'_>) -> bool { fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {     tcx.hir()         .visit_item_likes_in_module(module_def_id, &mut CheckAttrVisitor { tcx }.as_deep_visitor());+    if tcx.hir().local_def_id(CRATE_HIR_ID) == module_def_id {+        for attr in tcx.hir().krate_attrs() {+            CheckAttrVisitor { tcx }.check_doc_alias(attr, CRATE_HIR_ID, Target::Mod);+        }

 impl CheckAttrVisitor<'tcx> {                                 )                                 .emit();                         }+                        if attr.style == AttrStyle::Inner && CRATE_HIR_ID == hir_id {+                            self.tcx+                                .sess+                                .struct_span_err(+                                    meta.span(),+                                    "`#![doc(alias = \"...\")]` isn't allowed as a crate \+                                     level attribute",+                                )+                                .emit();

 impl CheckAttrVisitor<'tcx> {                                 )                                 .emit();                         }+                        if attr.style == AttrStyle::Inner && CRATE_HIR_ID == hir_id {

 impl CheckAttrVisitor<'tcx> {                                 )                                 .emit();

 fn is_c_like_enum(item: &Item<'_>) -> bool { fn check_mod_attrs(tcx: TyCtxt<'_>, module_def_id: LocalDefId) {     tcx.hir()         .visit_item_likes_in_module(module_def_id, &mut CheckAttrVisitor { tcx }.as_deep_visitor());+    if tcx.hir().local_def_id(CRATE_HIR_ID) == module_def_id {

 fn analysis(tcx: TyCtxt<'_>, cnum: CrateNum) -> Result<()> {                 sess.time("looking_for_derive_registrar", || proc_macro_decls::find(tcx));             },             {-                par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {-                    let local_def_id = tcx.hir().local_def_id(module);+                fn run_checks(tcx: TyCtxt<'_>, local_def_id: LocalDefId) {                     tcx.ensure().check_mod_loops(local_def_id);                     tcx.ensure().check_mod_attrs(local_def_id);                     tcx.ensure().check_mod_unstable_api_usage(local_def_id);                     tcx.ensure().check_mod_const_bodies(local_def_id);+                }++                par_iter(&tcx.hir().krate().modules).for_each(|(&module, _)| {+                    run_checks(tcx, tcx.hir().local_def_id(module));                 });+                // This check is run on its own because it needs to check attributes at the krate+                // level as well.+                run_checks(tcx, tcx.hir().local_def_id(CRATE_HIR_ID));