Skip to content

Commit

Permalink
rustdoc: clean up tuple <-> primitive conversion docs
Browse files Browse the repository at this point in the history 
This adds a minor missing feature to `fake_variadic`,
so that it can render `impl From<(T,)> for [T; 1]` correctly.
  • Loading branch information
@notriddle
notriddle committed Aug 24, 2024
1 parent f167efa commit 6df0ccf
Show file tree
Hide file tree
Showing 4 changed files with 122 additions and 55 deletions.
10 changes: 10 additions & 0 deletions compiler/rustc_passes/src/check_attr.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -951,6 +951,16 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
bare_fn_ty.decl.inputs.len() == 1
} else {
false
}
|| if let Some(&[hir::GenericArg::Type(ty)]) = i
.of_trait
.as_ref()
.and_then(|trait_ref| trait_ref.path.segments.last())
.map(|last_segment| last_segment.args().args)
{
matches!(&ty.kind, hir::TyKind::Tup([_]))
} else {
false
};
if !is_valid {
self.dcx().emit_err(errors::DocFakeVariadicNotValid { span: meta.span() });
Expand Down
36 changes: 21 additions & 15 deletions library/core/src/tuple.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -122,23 +122,29 @@ macro_rules! tuple_impls {
}
}

#[stable(feature = "array_tuple_conv", since = "1.71.0")]
impl<T> From<[T; ${count($T)}]> for ($(${ignore($T)} T,)+) {
#[inline]
#[allow(non_snake_case)]
fn from(array: [T; ${count($T)}]) -> Self {
let [$($T,)+] = array;
($($T,)+)
maybe_tuple_doc! {
$($T)+ @
#[stable(feature = "array_tuple_conv", since = "1.71.0")]
impl<T> From<[T; ${count($T)}]> for ($(${ignore($T)} T,)+) {
#[inline]
#[allow(non_snake_case)]
fn from(array: [T; ${count($T)}]) -> Self {
let [$($T,)+] = array;
($($T,)+)
}
}
}

#[stable(feature = "array_tuple_conv", since = "1.71.0")]
impl<T> From<($(${ignore($T)} T,)+)> for [T; ${count($T)}] {
#[inline]
#[allow(non_snake_case)]
fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
let ($($T,)+) = tuple;
[$($T,)+]
maybe_tuple_doc! {
$($T)+ @
#[stable(feature = "array_tuple_conv", since = "1.71.0")]
impl<T> From<($(${ignore($T)} T,)+)> for [T; ${count($T)}] {
#[inline]
#[allow(non_snake_case)]
fn from(tuple: ($(${ignore($T)} T,)+)) -> Self {
let ($($T,)+) = tuple;
[$($T,)+]
}
}
}
}
Expand All @@ -148,7 +154,7 @@ macro_rules! tuple_impls {
// Otherwise, it hides the docs entirely.
macro_rules! maybe_tuple_doc {
($a:ident @ #[$meta:meta] $item:item) => {
#[doc(fake_variadic)]
#[cfg_attr(not(bootstrap), doc(fake_variadic))]
#[doc = "This trait is implemented for tuples up to twelve items long."]
#[$meta]
$item
Expand Down
114 changes: 74 additions & 40 deletions src/librustdoc/html/format.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -1288,56 +1288,90 @@ impl clean::Impl {
if self.is_negative_trait_impl() {
write!(f, "!")?;
}
ty.print(cx).fmt(f)?;
if self.kind.is_fake_variadic()
&& let generics = ty.generics()
&& let &[inner_type] = generics.as_ref().map_or(&[][..], |v| &v[..])
{
let last = ty.last();
if f.alternate() {
write!(f, "{}<", last)?;
self.print_type(inner_type, f, use_absolute, cx)?;
write!(f, ">")?;
} else {
write!(f, "{}&lt;", anchor(ty.def_id(), last, cx).to_string())?;
self.print_type(inner_type, f, use_absolute, cx)?;
write!(f, "&gt;")?;
}
} else {
ty.print(cx).fmt(f)?;
}
write!(f, " for ")?;
}

if let clean::Type::Tuple(types) = &self.for_
&& let [clean::Type::Generic(name)] = &types[..]
&& (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_args!("({name}₁, {name}₂, …, {name}ₙ)"),
"#trait-implementations-1",
cx,
)?;
} else if let clean::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`

print_higher_ranked_params_with_space(&bare_fn.generic_params, cx).fmt(f)?;
bare_fn.safety.print_with_space().fmt(f)?;
print_abi_with_space(bare_fn.abi).fmt(f)?;
let ellipsis = if bare_fn.decl.c_variadic { ", ..." } else { "" };
primitive_link_fragment(
f,
PrimitiveType::Tuple,
format_args!("fn({name}₁, {name}₂, …, {name}ₙ{ellipsis})"),
"#trait-implementations-1",
cx,
)?;
// Write output.
if !bare_fn.decl.output.is_unit() {
write!(f, " -> ")?;
fmt_type(&bare_fn.decl.output, f, use_absolute, cx)?;
}
} else if let Some(ty) = self.kind.as_blanket_ty() {
if let Some(ty) = self.kind.as_blanket_ty() {
fmt_type(ty, f, use_absolute, cx)?;
} else {
fmt_type(&self.for_, f, use_absolute, cx)?;
self.print_type(&self.for_, f, use_absolute, cx)?;
}

print_where_clause(&self.generics, cx, 0, Ending::Newline).fmt(f)
})
}
fn print_type<'a, 'tcx: 'a>(
&self,
type_: &clean::Type,
f: &mut fmt::Formatter<'_>,
use_absolute: bool,
cx: &'a Context<'tcx>,
) -> Result<(), fmt::Error> {
if let clean::Type::Tuple(types) = type_
&& let [clean::Type::Generic(name)] = &types[..]
&& (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_args!("({name}₁, {name}₂, …, {name}ₙ)"),
"#trait-implementations-1",
cx,
)?;
} else if let clean::Type::Array(ty, len) = type_
&& let clean::Type::Generic(name) = &**ty
&& &len[..] == "1"
&& (self.kind.is_fake_variadic() || self.kind.is_auto())
{
primitive_link(f, PrimitiveType::Array, format_args!("[{name}; N]"), cx)?;
} else if let clean::BareFunction(bare_fn) = &type_
&& 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`

print_higher_ranked_params_with_space(&bare_fn.generic_params, cx).fmt(f)?;
bare_fn.safety.print_with_space().fmt(f)?;
print_abi_with_space(bare_fn.abi).fmt(f)?;
let ellipsis = if bare_fn.decl.c_variadic { ", ..." } else { "" };
primitive_link_fragment(
f,
PrimitiveType::Tuple,
format_args!("fn({name}₁, {name}₂, …, {name}ₙ{ellipsis})"),
"#trait-implementations-1",
cx,
)?;
// Write output.
if !bare_fn.decl.output.is_unit() {
write!(f, " -> ")?;
fmt_type(&bare_fn.decl.output, f, use_absolute, cx)?;
}
} else {
fmt_type(&type_, f, use_absolute, cx)?;
}
Ok(())
}
}

impl clean::Arguments {
Expand Down
17 changes: 17 additions & 0 deletions tests/rustdoc/primitive-tuple-variadic.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,3 +16,20 @@ pub trait Bar {}
//@ has - '//section[@id="impl-Bar-for-(U,)"]/h3' 'impl<U: Foo> Bar for (U₁, U₂, …, Uₙ)'
#[doc(fake_variadic)]
impl<U: Foo> Bar for (U,) {}

pub trait Baz<T> { fn baz(&self) -> T { todo!() } }

//@ has foo/trait.Baz.html
//@ has - '//section[@id="impl-Baz%3C(T,)%3E-for-%5BT;+1%5D"]/h3' 'impl<T> Baz<(T₁, T₂, …, Tₙ)> for [T; N]'
#[doc(fake_variadic)]
impl<T> Baz<(T,)> for [T; 1] {}

//@ has foo/trait.Baz.html
//@ has - '//section[@id="impl-Baz%3C%5BT;+1%5D%3E-for-(T,)"]/h3' 'impl<T> Baz<[T; N]> for (T₁, T₂, …, Tₙ)'
#[doc(fake_variadic)]
impl<T> Baz<[T; 1]> for (T,) {}

//@ has foo/trait.Baz.html
//@ has - '//section[@id="impl-Baz%3CT%3E-for-(T,)"]/h3' 'impl<T> Baz<T> for (T₁, T₂, …, Tₙ)'
#[doc(fake_variadic)]
impl<T> Baz<T> for (T,) {}

0 comments on commit 6df0ccf

Please sign in to comment.