rustdoc: extend #[doc(tuple_variadic)] to fn pointers

The attribute is also renamed `fake_variadic`.
2024-10-31 06:22:00 +00:00 · 2022-06-16 09:50:57 -07:00 · 2022-06-16 09:50:57 -07:00 · 1169832f2f
commit 1169832f2f
parent 263edd43c5
21 changed files with 61 additions and 42 deletions
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@ -402,8 +402,8 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                    gate_feature_post!(self, rustdoc_internals, attr.span, msg);
                }

-                if nested_meta.has_name(sym::tuple_variadic) {
-                    let msg = "`#[doc(tuple_variadic)]` is meant for internal use only";
+                if nested_meta.has_name(sym::fake_variadic) {
+                    let msg = "`#[doc(fake_variadic)]` is meant for internal use only";
                    gate_feature_post!(self, rustdoc_internals, attr.span, msg);
                }
            }
--- a/compiler/rustc_error_messages/locales/en-US/passes.ftl
+++ b/compiler/rustc_error_messages/locales/en-US/passes.ftl
@ -81,8 +81,8 @@ passes-doc-keyword-not-mod = `#[doc(keyword = "...")]` should be used on modules

 passes-doc-keyword-invalid-ident = `{$doc_keyword}` is not a valid identifier

-passes-doc-tuple-variadic-not-first =
-    `#[doc(tuple_variadic)]` must be used on the first of a set of tuple trait impls with varying arity
+passes-doc-fake-variadic-not-valid =
+    `#[doc(fake_variadic)]` must be used on the first of a set of tuple or fn pointer trait impls with varying arity

 passes-doc-keyword-only-impl = `#[doc(keyword = "...")]` should be used on impl blocks

--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@ -706,14 +706,20 @@ impl CheckAttrVisitor<'_> {
        true
    }

-    fn check_doc_tuple_variadic(&self, meta: &NestedMetaItem, hir_id: HirId) -> bool {
+    fn check_doc_fake_variadic(&self, meta: &NestedMetaItem, hir_id: HirId) -> bool {
        match self.tcx.hir().find(hir_id).and_then(|node| match node {
            hir::Node::Item(item) => Some(&item.kind),
            _ => None,
        }) {
            Some(ItemKind::Impl(ref i)) => {
-                if !matches!(&i.self_ty.kind, hir::TyKind::Tup([_])) {
-                    self.tcx.sess.emit_err(errors::DocTupleVariadicNotFirst { span: meta.span() });
+                let is_valid = matches!(&i.self_ty.kind, hir::TyKind::Tup([_]))
+                    || if let hir::TyKind::BareFn(bare_fn_ty) = &i.self_ty.kind {
+                        bare_fn_ty.decl.inputs.len() == 1
+                    } else {
+                        false
+                    };
+                if !is_valid {
+                    self.tcx.sess.emit_err(errors::DocFakeVariadicNotValid { span: meta.span() });
                    return false;
                }
            }
@ -887,9 +893,9 @@ impl CheckAttrVisitor<'_> {
                            is_valid = false
                        }

-                        sym::tuple_variadic
-                            if !self.check_attr_not_crate_level(meta, hir_id, "tuple_variadic")
-                                || !self.check_doc_tuple_variadic(meta, hir_id) =>
+                        sym::fake_variadic
+                            if !self.check_attr_not_crate_level(meta, hir_id, "fake_variadic")
+                                || !self.check_doc_fake_variadic(meta, hir_id) =>
                        {
                            is_valid = false
                        }
@ -939,7 +945,7 @@ impl CheckAttrVisitor<'_> {
                        | sym::notable_trait
                        | sym::passes
                        | sym::plugins
-                        | sym::tuple_variadic => {}
+                        | sym::fake_variadic => {}

                        sym::test => {
                            if !self.check_test_attr(meta, hir_id) {
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@ -212,8 +212,8 @@ pub struct DocKeywordInvalidIdent {
 }

 #[derive(SessionDiagnostic)]
-#[error(passes::doc_tuple_variadic_not_first)]
-pub struct DocTupleVariadicNotFirst {
+#[error(passes::doc_fake_variadic_not_valid)]
+pub struct DocFakeVariadicNotValid {
    #[primary_span]
    pub span: Span,
 }
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@ -685,6 +685,7 @@ symbols! {
        fabsf32,
        fabsf64,
        fadd_fast,
+        fake_variadic,
        fdiv_fast,
        feature,
        fence,
@ -1460,7 +1461,6 @@ symbols! {
        tuple,
        tuple_from_req,
        tuple_indexing,
-        tuple_variadic,
        two_phase,
        ty,
        type_alias_enum_variants,
--- a/library/core/src/fmt/mod.rs
+++ b/library/core/src/fmt/mod.rs
@ -2562,7 +2562,7 @@ macro_rules! tuple {

 macro_rules! maybe_tuple_doc {
    ($a:ident @ #[$meta:meta] $item:item) => {
-        #[doc(tuple_variadic)]
+        #[cfg_attr(not(bootstrap), doc(fake_variadic))]
        #[doc = "This trait is implemented for tuples up to twelve items long."]
        #[$meta]
        $item
--- a/library/core/src/hash/mod.rs
+++ b/library/core/src/hash/mod.rs
@ -900,7 +900,7 @@ mod impls {

    macro_rules! maybe_tuple_doc {
        ($a:ident @ #[$meta:meta] $item:item) => {
-            #[doc(tuple_variadic)]
+            #[cfg_attr(not(bootstrap), doc(fake_variadic))]
            #[doc = "This trait is implemented for tuples up to twelve items long."]
            #[$meta]
            $item
--- a/library/core/src/primitive_docs.rs
+++ b/library/core/src/primitive_docs.rs
@ -996,7 +996,7 @@ impl<T> (T,) {}
 // Fake impl that's only really used for docs.
 #[cfg(doc)]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[doc(tuple_variadic)]
+#[cfg_attr(not(bootstrap), doc(fake_variadic))]
 /// This trait is implemented on arbitrary-length tuples.
 impl<T: Clone> Clone for (T,) {
    fn clone(&self) -> Self {
@ -1007,7 +1007,7 @@ impl<T: Clone> Clone for (T,) {
 // Fake impl that's only really used for docs.
 #[cfg(doc)]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[doc(tuple_variadic)]
+#[cfg_attr(not(bootstrap), doc(fake_variadic))]
 /// This trait is implemented on arbitrary-length tuples.
 impl<T: Copy> Copy for (T,) {
    // empty
--- a/library/core/src/tuple.rs
+++ b/library/core/src/tuple.rs
@ -107,7 +107,7 @@ macro_rules! tuple_impls {
 // Otherwise, it hides the docs entirely.
 macro_rules! maybe_tuple_doc {
    ($a:ident @ #[$meta:meta] $item:item) => {
-        #[doc(tuple_variadic)]
+        #[cfg_attr(not(bootstrap), doc(fake_variadic))]
        #[doc = "This trait is implemented for tuples up to twelve items long."]
        #[$meta]
        $item
--- a/library/std/src/primitive_docs.rs
+++ b/library/std/src/primitive_docs.rs
@ -996,7 +996,7 @@ impl<T> (T,) {}
 // Fake impl that's only really used for docs.
 #[cfg(doc)]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[doc(tuple_variadic)]
+#[cfg_attr(not(bootstrap), doc(fake_variadic))]
 /// This trait is implemented on arbitrary-length tuples.
 impl<T: Clone> Clone for (T,) {
    fn clone(&self) -> Self {
@ -1007,7 +1007,7 @@ impl<T: Clone> Clone for (T,) {
 // Fake impl that's only really used for docs.
 #[cfg(doc)]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[doc(tuple_variadic)]
+#[cfg_attr(not(bootstrap), doc(fake_variadic))]
 /// This trait is implemented on arbitrary-length tuples.
 impl<T: Copy> Copy for (T,) {
    // empty
--- a/src/librustdoc/clean/inline.rs
+++ b/src/librustdoc/clean/inline.rs
@ -506,8 +506,8 @@ pub(crate) fn build_impl(
            for_,
            items: trait_items,
            polarity,
-            kind: if utils::has_doc_flag(tcx, did, sym::tuple_variadic) {
-                ImplKind::TupleVaradic
+            kind: if utils::has_doc_flag(tcx, did, sym::fake_variadic) {
+                ImplKind::FakeVaradic
            } else {
                ImplKind::Normal
            },
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@ -2005,8 +2005,8 @@ fn clean_impl<'tcx>(
            for_,
            items,
            polarity: tcx.impl_polarity(def_id),
-            kind: if utils::has_doc_flag(tcx, def_id.to_def_id(), sym::tuple_variadic) {
-                ImplKind::TupleVaradic
+            kind: if utils::has_doc_flag(tcx, def_id.to_def_id(), sym::fake_variadic) {
+                ImplKind::FakeVaradic
            } else {
                ImplKind::Normal
            },
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@ -2394,7 +2394,7 @@ impl Impl {
 pub(crate) enum ImplKind {
    Normal,
    Auto,
-    TupleVaradic,
+    FakeVaradic,
    Blanket(Box<Type>),
 }

@ -2407,8 +2407,8 @@ impl ImplKind {
        matches!(self, ImplKind::Blanket(_))
    }

-    pub(crate) fn is_tuple_variadic(&self) -> bool {
-        matches!(self, ImplKind::TupleVaradic)
+    pub(crate) fn is_fake_variadic(&self) -> bool {
+        matches!(self, ImplKind::FakeVaradic)
    }

    pub(crate) fn as_blanket_ty(&self) -> Option<&Type> {
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@ -1165,10 +1165,23 @@ impl clean::Impl {

            if let clean::Type::Tuple(types) = &self.for_ &&
                let [clean::Type::Generic(name)] = &types[..] &&
-                (self.kind.is_tuple_variadic() || self.kind.is_auto()) {
+                (self.kind.is_fake_variadic() || self.kind.is_auto()) {
                // Hardcoded anchor library/core/src/primitive_docs.rs
                // Link should match `# Trait implementations`
                primitive_link_fragment(f, PrimitiveType::Tuple, &format!("({name}₁, {name}₂, …, {name}ₙ)"), "#trait-implementations-1", cx)?;
+            } else if let clean::Type::BareFunction(bare_fn) = &self.for_ &&
+                let [clean::Argument { type_: clean::Type::Generic(name), .. }] = &bare_fn.decl.inputs.values[..] &&
+                (self.kind.is_fake_variadic() || self.kind.is_auto()) {
+                // Hardcoded anchor library/core/src/primitive_docs.rs
+                // Link should match `# Trait implementations`
+                primitive_link_fragment(f, PrimitiveType::Tuple, &format!("fn ({name}₁, {name}₂, …, {name}ₙ)"), "#trait-implementations-1", cx)?;
+                // Not implemented.
+                assert!(!bare_fn.decl.c_variadic);
+                // Write output.
+                if let clean::FnRetTy::Return(ty) = &bare_fn.decl.output {
+                    write!(f, " -> ")?;
+                    fmt_type(ty, f, use_absolute, cx)?;
+                }
            } else if let Some(ty) = self.kind.as_blanket_ty() {
                fmt_type(ty, f, use_absolute, cx)?;
            } else {
--- a/src/librustdoc/json/conversions.rs
+++ b/src/librustdoc/json/conversions.rs
@ -574,7 +574,7 @@ impl FromWithTcx<clean::Impl> for Impl {
        let trait_ = trait_.map(|path| clean::Type::Path { path }.into_tcx(tcx));
        // FIXME: use something like ImplKind in JSON?
        let (synthetic, blanket_impl) = match kind {
-            clean::ImplKind::Normal | clean::ImplKind::TupleVaradic => (false, None),
+            clean::ImplKind::Normal | clean::ImplKind::FakeVaradic => (false, None),
            clean::ImplKind::Auto => (true, None),
            clean::ImplKind::Blanket(ty) => (false, Some(*ty)),
        };
--- a/src/test/rustdoc-ui/tuple-variadic-check.rs
+++ b/src/test/rustdoc-ui/tuple-variadic-check.rs
@ -3,13 +3,13 @@
 trait Mine {}

 // This one is fine
-#[doc(tuple_variadic)]
+#[doc(fake_variadic)]
 impl<T> Mine for (T,) {}

 trait Mine2 {}

 // This one is not
-#[doc(tuple_variadic)] //~ ERROR
+#[doc(fake_variadic)] //~ ERROR
 impl<T, U> Mine for (T,U) {}

 fn main() {}
--- a/src/test/rustdoc-ui/tuple-variadic-check.stderr
+++ b/src/test/rustdoc-ui/tuple-variadic-check.stderr
@ -1,8 +1,8 @@
-error: `#[doc(tuple_variadic)]` must be used on the first of a set of tuple trait impls with varying arity
+error: `#[doc(fake_variadic)]` must be used on the first of a set of tuple or fn pointer trait impls with varying arity
  --> $DIR/tuple-variadic-check.rs:12:7
   |
-LL | #[doc(tuple_variadic)]
-   |       ^^^^^^^^^^^^^^
+LL | #[doc(fake_variadic)]
+   |       ^^^^^^^^^^^^^

 error: aborting due to previous error

--- a/src/test/rustdoc/primitive-tuple-auto-trait.rs
+++ b/src/test/rustdoc/primitive-tuple-auto-trait.rs
@ -16,7 +16,7 @@
 // @has - '//h2[@id="trait-implementations-1"]' 'Trait implementations'
 /// # Trait implementations
 ///
-/// This header is hard-coded in the HTML format linking for `#[doc(tuple_variadics)]`.
+/// This header is hard-coded in the HTML format linking for `#[doc(fake_variadics)]`.
 /// To make sure it gets linked correctly, we need to make sure the hardcoded anchor
 /// in the code matches what rustdoc generates for the header.
 mod tuple_prim {}
--- a/src/test/rustdoc/primitive-tuple-variadic.rs
+++ b/src/test/rustdoc/primitive-tuple-variadic.rs
@ -7,12 +7,12 @@ pub trait Foo {}

 // @has foo/trait.Foo.html
 // @has - '//section[@id="impl-Foo-for-(T%2C)"]/h3' 'impl<T> Foo for (T₁, T₂, …, Tₙ)'
-#[doc(tuple_variadic)]
+#[doc(fake_variadic)]
 impl<T> Foo for (T,) {}

 pub trait Bar {}

 // @has foo/trait.Bar.html
 // @has - '//section[@id="impl-Bar-for-(U%2C)"]/h3' 'impl<U: Foo> Bar for (U₁, U₂, …, Uₙ)'
-#[doc(tuple_variadic)]
+#[doc(fake_variadic)]
 impl<U: Foo> Bar for (U,) {}
--- a/src/test/ui/feature-gates/feature-gate-rustdoc_internals.rs
+++ b/src/test/ui/feature-gates/feature-gate-rustdoc_internals.rs
@ -4,7 +4,7 @@ mod foo {}

 trait Mine {}

-#[doc(tuple_variadic)]  //~ ERROR: `#[doc(tuple_variadic)]` is meant for internal use only
+#[doc(fake_variadic)]  //~ ERROR: `#[doc(fake_variadic)]` is meant for internal use only
 impl<T> Mine for (T,) {}

 fn main() {}
--- a/src/test/ui/feature-gates/feature-gate-rustdoc_internals.stderr
+++ b/src/test/ui/feature-gates/feature-gate-rustdoc_internals.stderr
@ -7,11 +7,11 @@ LL | #[doc(keyword = "match")]
   = note: see issue #90418 <https://github.com/rust-lang/rust/issues/90418> for more information
   = help: add `#![feature(rustdoc_internals)]` to the crate attributes to enable

-error[E0658]: `#[doc(tuple_variadic)]` is meant for internal use only
+error[E0658]: `#[doc(fake_variadic)]` is meant for internal use only
  --> $DIR/feature-gate-rustdoc_internals.rs:7:1
   |
-LL | #[doc(tuple_variadic)]
-   | ^^^^^^^^^^^^^^^^^^^^^^
+LL | #[doc(fake_variadic)]
+   | ^^^^^^^^^^^^^^^^^^^^^
   |
   = note: see issue #90418 <https://github.com/rust-lang/rust/issues/90418> for more information
   = help: add `#![feature(rustdoc_internals)]` to the crate attributes to enable