1 use clean
::AttributesExt
;
3 use rustc_data_structures
::fx
::{FxHashMap, FxHashSet}
;
5 use rustc_hir
::def
::CtorKind
;
6 use rustc_hir
::def_id
::DefId
;
7 use rustc_middle
::middle
::stability
;
8 use rustc_middle
::span_bug
;
9 use rustc_middle
::ty
::layout
::LayoutError
;
10 use rustc_middle
::ty
::{self, Adt, TyCtxt}
;
11 use rustc_span
::hygiene
::MacroKind
;
12 use rustc_span
::symbol
::{kw, sym, Symbol}
;
13 use rustc_target
::abi
::{LayoutS, Primitive, TagEncoding, VariantIdx, Variants}
;
14 use std
::cmp
::Ordering
;
19 collect_paths_for_type
, document
, ensure_trailing_slash
, get_filtered_impls_for_reference
,
20 item_ty_to_section
, notable_traits_button
, notable_traits_json
, render_all_impls
,
21 render_assoc_item
, render_assoc_items
, render_attributes_in_code
, render_attributes_in_pre
,
22 render_impl
, render_rightside
, render_stability_since_raw
,
23 render_stability_since_raw_with_extra
, AssocItemLink
, Context
, ImplRenderingParameters
,
26 use crate::config
::ModuleSorting
;
27 use crate::formats
::item_type
::ItemType
;
28 use crate::formats
::{AssocItemRender, Impl, RenderMode}
;
29 use crate::html
::escape
::Escape
;
30 use crate::html
::format
::{
31 join_with_double_colon
, print_abi_with_space
, print_constness_with_space
, print_where_clause
,
32 visibility_print_with_space
, Buffer
, Ending
, PrintWithSpace
,
34 use crate::html
::layout
::Page
;
35 use crate::html
::markdown
::{HeadingOffset, MarkdownSummaryLine}
;
36 use crate::html
::url_parts_builder
::UrlPartsBuilder
;
37 use crate::html
::{highlight, static_files}
;
40 use itertools
::Itertools
;
42 const ITEM_TABLE_OPEN
: &str = "<div class=\"item-table\">";
43 const ITEM_TABLE_CLOSE
: &str = "</div>";
44 const ITEM_TABLE_ROW_OPEN
: &str = "<div class=\"item-row\">";
45 const ITEM_TABLE_ROW_CLOSE
: &str = "</div>";
47 // A component in a `use` path, like `string` in std::string::ToString
48 struct PathComponent
{
54 #[template(path = "print_item.html")]
56 static_root_path
: &'a
str,
57 clipboard_svg
: &'
static static_files
::StaticFile
,
61 path_components
: Vec
<PathComponent
>,
62 stability_since_raw
: &'a
str,
63 src_href
: Option
<&'a
str>,
66 /// Calls `print_where_clause` and returns `true` if a `where` clause was generated.
67 fn print_where_clause_and_check
<'a
, 'tcx
: 'a
>(
69 gens
: &'a clean
::Generics
,
70 cx
: &'a Context
<'tcx
>,
72 let len_before
= buffer
.len();
73 write
!(buffer
, "{}", print_where_clause(gens
, cx
, 0, Ending
::Newline
));
74 len_before
!= buffer
.len()
77 pub(super) fn print_item(
83 debug_assert
!(!item
.is_stripped());
84 let typ
= match *item
.kind
{
85 clean
::ModuleItem(_
) => {
92 clean
::FunctionItem(..) | clean
::ForeignFunctionItem(..) => "Function ",
93 clean
::TraitItem(..) => "Trait ",
94 clean
::StructItem(..) => "Struct ",
95 clean
::UnionItem(..) => "Union ",
96 clean
::EnumItem(..) => "Enum ",
97 clean
::TypedefItem(..) => "Type Definition ",
98 clean
::MacroItem(..) => "Macro ",
99 clean
::ProcMacroItem(ref mac
) => match mac
.kind
{
100 MacroKind
::Bang
=> "Macro ",
101 MacroKind
::Attr
=> "Attribute Macro ",
102 MacroKind
::Derive
=> "Derive Macro ",
104 clean
::PrimitiveItem(..) => "Primitive Type ",
105 clean
::StaticItem(..) | clean
::ForeignStaticItem(..) => "Static ",
106 clean
::ConstantItem(..) => "Constant ",
107 clean
::ForeignTypeItem
=> "Foreign Type ",
108 clean
::KeywordItem
=> "Keyword ",
109 clean
::OpaqueTyItem(..) => "Opaque Type ",
110 clean
::TraitAliasItem(..) => "Trait Alias ",
112 // We don't generate pages for any other type.
116 let mut stability_since_raw
= Buffer
::new();
117 render_stability_since_raw(
118 &mut stability_since_raw
,
119 item
.stable_since(cx
.tcx()),
120 item
.const_stability(cx
.tcx()),
124 let stability_since_raw
: String
= stability_since_raw
.into_inner();
128 // When this item is part of a `crate use` in a downstream crate, the
129 // source link in the downstream documentation will actually come back to
130 // this page, and this link will be auto-clicked. The `id` attribute is
131 // used to find the link to auto-click.
133 if cx
.include_sources
&& !item
.is_primitive() { cx.src_href(item) }
else { None }
;
135 let path_components
= if item
.is_primitive() || item
.is_keyword() {
138 let cur
= &cx
.current
;
139 let amt
= if item
.is_mod() { cur.len() - 1 }
else { cur.len() }
;
143 .map(|(i
, component
)| PathComponent
{
144 path
: "../".repeat(cur
.len() - i
- 1),
150 let item_vars
= ItemVars
{
151 static_root_path
: &page
.get_static_root_path(),
152 clipboard_svg
: &static_files
::STATIC_FILES
.clipboard_svg
,
154 name
: item
.name
.as_ref().unwrap().as_str(),
155 item_type
: &item
.type_().to_string(),
157 stability_since_raw
: &stability_since_raw
,
158 src_href
: src_href
.as_deref(),
161 item_vars
.render_into(buf
).unwrap();
164 clean
::ModuleItem(ref m
) => item_module(buf
, cx
, item
, &m
.items
),
165 clean
::FunctionItem(ref f
) | clean
::ForeignFunctionItem(ref f
) => {
166 item_function(buf
, cx
, item
, f
)
168 clean
::TraitItem(ref t
) => item_trait(buf
, cx
, item
, t
),
169 clean
::StructItem(ref s
) => item_struct(buf
, cx
, item
, s
),
170 clean
::UnionItem(ref s
) => item_union(buf
, cx
, item
, s
),
171 clean
::EnumItem(ref e
) => item_enum(buf
, cx
, item
, e
),
172 clean
::TypedefItem(ref t
) => item_typedef(buf
, cx
, item
, t
),
173 clean
::MacroItem(ref m
) => item_macro(buf
, cx
, item
, m
),
174 clean
::ProcMacroItem(ref m
) => item_proc_macro(buf
, cx
, item
, m
),
175 clean
::PrimitiveItem(_
) => item_primitive(buf
, cx
, item
),
176 clean
::StaticItem(ref i
) | clean
::ForeignStaticItem(ref i
) => item_static(buf
, cx
, item
, i
),
177 clean
::ConstantItem(ref c
) => item_constant(buf
, cx
, item
, c
),
178 clean
::ForeignTypeItem
=> item_foreign_type(buf
, cx
, item
),
179 clean
::KeywordItem
=> item_keyword(buf
, cx
, item
),
180 clean
::OpaqueTyItem(ref e
) => item_opaque_ty(buf
, cx
, item
, e
),
181 clean
::TraitAliasItem(ref ta
) => item_trait_alias(buf
, cx
, item
, ta
),
183 // We don't generate pages for any other type.
188 // Render notable-traits.js used for all methods in this module.
189 if !cx
.types_with_notable_traits
.is_empty() {
192 r
#"<script type="text/json" id="notable-traits-data">{}</script>"#,
193 notable_traits_json(cx
.types_with_notable_traits
.iter(), cx
)
195 cx
.types_with_notable_traits
.clear();
199 /// For large structs, enums, unions, etc, determine whether to hide their fields
200 fn should_hide_fields(n_fields
: usize) -> bool
{
204 fn toggle_open(w
: &mut Buffer
, text
: impl fmt
::Display
) {
207 "<details class=\"rustdoc-toggle type-contents-toggle\">\
208 <summary class=\"hideme\">\
209 <span>Show {}</span>\
215 fn toggle_close(w
: &mut Buffer
) {
216 w
.write_str("</details>");
219 fn item_module(w
: &mut Buffer
, cx
: &mut Context
<'_
>, item
: &clean
::Item
, items
: &[clean
::Item
]) {
220 document(w
, cx
, item
, None
, HeadingOffset
::H2
);
222 let mut indices
= (0..items
.len()).filter(|i
| !items
[*i
].is_stripped()).collect
::<Vec
<usize>>();
224 // the order of item types in the listing
225 fn reorder(ty
: ItemType
) -> u8 {
227 ItemType
::ExternCrate
=> 0,
228 ItemType
::Import
=> 1,
229 ItemType
::Primitive
=> 2,
230 ItemType
::Module
=> 3,
231 ItemType
::Macro
=> 4,
232 ItemType
::Struct
=> 5,
234 ItemType
::Constant
=> 7,
235 ItemType
::Static
=> 8,
236 ItemType
::Trait
=> 9,
237 ItemType
::Function
=> 10,
238 ItemType
::Typedef
=> 12,
239 ItemType
::Union
=> 13,
251 let ty1
= i1
.type_();
252 let ty2
= i2
.type_();
253 if item_ty_to_section(ty1
) != item_ty_to_section(ty2
)
254 || (ty1
!= ty2
&& (ty1
== ItemType
::ExternCrate
|| ty2
== ItemType
::ExternCrate
))
256 return (reorder(ty1
), idx1
).cmp(&(reorder(ty2
), idx2
));
258 let s1
= i1
.stability(tcx
).as_ref().map(|s
| s
.level
);
259 let s2
= i2
.stability(tcx
).as_ref().map(|s
| s
.level
);
260 if let (Some(a
), Some(b
)) = (s1
, s2
) {
261 match (a
.is_stable(), b
.is_stable()) {
262 (true, true) | (false, false) => {}
263 (false, true) => return Ordering
::Less
,
264 (true, false) => return Ordering
::Greater
,
267 let lhs
= i1
.name
.unwrap_or(kw
::Empty
);
268 let rhs
= i2
.name
.unwrap_or(kw
::Empty
);
269 compare_names(lhs
.as_str(), rhs
.as_str())
272 match cx
.shared
.module_sorting
{
273 ModuleSorting
::Alphabetical
=> {
274 indices
.sort_by(|&i1
, &i2
| cmp(&items
[i1
], &items
[i2
], i1
, i2
, cx
.tcx()));
276 ModuleSorting
::DeclarationOrder
=> {}
278 // This call is to remove re-export duplicates in cases such as:
281 // pub(crate) mod foo {
282 // pub(crate) mod bar {
283 // pub(crate) trait Double { fn foo(); }
287 // pub(crate) use foo::bar::*;
288 // pub(crate) use foo::*;
291 // `Double` will appear twice in the generated docs.
293 // FIXME: This code is quite ugly and could be improved. Small issue: DefId
294 // can be identical even if the elements are different (mostly in imports).
295 // So in case this is an import, we keep everything by adding a "unique id"
296 // (which is the position in the vector).
297 indices
.dedup_by_key(|i
| {
300 if items
[*i
].name
.is_some() { Some(full_path(cx, &items[*i])) }
else { None }
,
302 if items
[*i
].is_import() { *i }
else { 0 }
,
306 debug
!("{:?}", indices
);
307 let mut last_section
= None
;
309 for &idx
in &indices
{
310 let myitem
= &items
[idx
];
311 if myitem
.is_stripped() {
315 let my_section
= item_ty_to_section(myitem
.type_());
316 if Some(my_section
) != last_section
{
317 if last_section
.is_some() {
318 w
.write_str(ITEM_TABLE_CLOSE
);
320 last_section
= Some(my_section
);
323 "<h2 id=\"{id}\" class=\"small-section-header\">\
324 <a href=\"#{id}\">{name}</a>\
327 id
= cx
.derive_id(my_section
.id().to_owned()),
328 name
= my_section
.name(),
334 clean
::ExternCrateItem { ref src }
=> {
335 use crate::html
::format
::anchor
;
337 w
.write_str(ITEM_TABLE_ROW_OPEN
);
341 "<div class=\"item-left\"><code>{}extern crate {} as {};",
342 visibility_print_with_space(myitem
.visibility(tcx
), myitem
.item_id
, cx
),
343 anchor(myitem
.item_id
.expect_def_id(), src
, cx
),
344 myitem
.name
.unwrap(),
348 "<div class=\"item-left\"><code>{}extern crate {};",
349 visibility_print_with_space(myitem
.visibility(tcx
), myitem
.item_id
, cx
),
350 anchor(myitem
.item_id
.expect_def_id(), myitem
.name
.unwrap(), cx
),
353 w
.write_str("</code></div>");
354 w
.write_str(ITEM_TABLE_ROW_CLOSE
);
357 clean
::ImportItem(ref import
) => {
358 let (stab
, stab_tags
) = if let Some(import_def_id
) = import
.source
.did
{
359 let ast_attrs
= cx
.tcx().get_attrs_unchecked(import_def_id
);
360 let import_attrs
= Box
::new(clean
::Attributes
::from_ast(ast_attrs
));
362 // Just need an item with the correct def_id and attrs
363 let import_item
= clean
::Item
{
364 item_id
: import_def_id
.into(),
366 cfg
: ast_attrs
.cfg(cx
.tcx(), &cx
.cache().hidden_cfg
),
370 let stab
= import_item
.stability_class(cx
.tcx());
371 let stab_tags
= Some(extra_info_tags(&import_item
, item
, cx
.tcx()));
377 let add
= if stab
.is_some() { " " }
else { "" }
;
379 w
.write_str(ITEM_TABLE_ROW_OPEN
);
380 let id
= match import
.kind
{
381 clean
::ImportKind
::Simple(s
) => {
382 format
!(" id=\"{}\"", cx
.derive_id(format
!("reexport.{}", s
)))
384 clean
::ImportKind
::Glob
=> String
::new(),
386 let stab_tags
= stab_tags
.unwrap_or_default();
387 let (stab_tags_before
, stab_tags_after
) = if stab_tags
.is_empty() {
390 ("<div class=\"item-right docblock-short\">", "</div>")
394 "<div class=\"item-left {stab}{add}import-item\"{id}>\
395 <code>{vis}{imp}</code>\
397 {stab_tags_before}{stab_tags}{stab_tags_after}",
398 stab
= stab
.unwrap_or_default(),
399 vis
= visibility_print_with_space(myitem
.visibility(tcx
), myitem
.item_id
, cx
),
400 imp
= import
.print(cx
),
402 w
.write_str(ITEM_TABLE_ROW_CLOSE
);
406 if myitem
.name
.is_none() {
410 let unsafety_flag
= match *myitem
.kind
{
411 clean
::FunctionItem(_
) | clean
::ForeignFunctionItem(_
)
412 if myitem
.fn_header(cx
.tcx()).unwrap().unsafety
413 == hir
::Unsafety
::Unsafe
=>
415 "<sup title=\"unsafe function\">⚠</sup>"
420 let stab
= myitem
.stability_class(cx
.tcx());
421 let add
= if stab
.is_some() { " " }
else { "" }
;
423 let visibility_emoji
= match myitem
.visibility(tcx
) {
424 Some(ty
::Visibility
::Restricted(_
)) => {
425 "<span title=\"Restricted Visibility\"> 🔒</span> "
430 let doc_value
= myitem
.doc_value().unwrap_or_default();
431 w
.write_str(ITEM_TABLE_ROW_OPEN
);
432 let docs
= MarkdownSummaryLine(&doc_value
, &myitem
.links(cx
)).into_string();
433 let (docs_before
, docs_after
) = if docs
.is_empty() {
436 ("<div class=\"item-right docblock-short\">", "</div>")
440 "<div class=\"item-left {stab}{add}module-item\">\
441 <a class=\"{class}\" href=\"{href}\" title=\"{title}\">{name}</a>\
446 {docs_before}{docs}{docs_after}",
447 name
= myitem
.name
.unwrap(),
448 visibility_emoji
= visibility_emoji
,
449 stab_tags
= extra_info_tags(myitem
, item
, cx
.tcx()),
450 class
= myitem
.type_(),
452 stab
= stab
.unwrap_or_default(),
453 unsafety_flag
= unsafety_flag
,
454 href
= item_path(myitem
.type_(), myitem
.name
.unwrap().as_str()),
455 title
= [full_path(cx
, myitem
), myitem
.type_().to_string()]
457 .filter_map(|s
| if !s
.is_empty() { Some(s.as_str()) }
else { None }
)
461 w
.write_str(ITEM_TABLE_ROW_CLOSE
);
466 if last_section
.is_some() {
467 w
.write_str(ITEM_TABLE_CLOSE
);
471 /// Render the stability, deprecation and portability tags that are displayed in the item's summary
472 /// at the module level.
473 fn extra_info_tags(item
: &clean
::Item
, parent
: &clean
::Item
, tcx
: TyCtxt
<'_
>) -> String
{
474 let mut tags
= String
::new();
476 fn tag_html(class
: &str, title
: &str, contents
: &str) -> String
{
477 format
!(r
#"<span class="stab {}" title="{}">{}</span>"#, class, Escape(title), contents)
480 // The trailing space after each tag is to space it properly against the rest of the docs.
481 if let Some(depr
) = &item
.deprecation(tcx
) {
482 let mut message
= "Deprecated";
483 if !stability
::deprecation_in_effect(depr
) {
484 message
= "Deprecation planned";
486 tags
+= &tag_html("deprecated", "", message
);
489 // The "rustc_private" crates are permanently unstable so it makes no sense
490 // to render "unstable" everywhere.
491 if item
.stability(tcx
).as_ref().map(|s
| s
.is_unstable() && s
.feature
!= sym
::rustc_private
)
494 tags
+= &tag_html("unstable", "", "Experimental");
497 let cfg
= match (&item
.cfg
, parent
.cfg
.as_ref()) {
498 (Some(cfg
), Some(parent_cfg
)) => cfg
.simplify_with(parent_cfg
),
499 (cfg
, _
) => cfg
.as_deref().cloned(),
502 debug
!("Portability name={:?} {:?} - {:?} = {:?}", item
.name
, item
.cfg
, parent
.cfg
, cfg
);
503 if let Some(ref cfg
) = cfg
{
504 tags
+= &tag_html("portability", &cfg
.render_long_plain(), &cfg
.render_short_html());
510 fn item_function(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, f
: &clean
::Function
) {
512 let header
= it
.fn_header(tcx
).expect("printing a function which isn't a function");
513 let constness
= print_constness_with_space(&header
.constness
, it
.const_stability(tcx
));
514 let unsafety
= header
.unsafety
.print_with_space();
515 let abi
= print_abi_with_space(header
.abi
).to_string();
516 let asyncness
= header
.asyncness
.print_with_space();
517 let visibility
= visibility_print_with_space(it
.visibility(tcx
), it
.item_id
, cx
).to_string();
518 let name
= it
.name
.unwrap();
520 let generics_len
= format
!("{:#}", f
.generics
.print(cx
)).len();
521 let header_len
= "fn ".len()
527 + name
.as_str().len()
531 f
.decl
.output
.as_return().and_then(|output
| notable_traits_button(output
, cx
));
533 wrap_into_item_decl(w
, |w
| {
534 wrap_item(w
, "fn", |w
| {
535 render_attributes_in_pre(w
, it
, "");
536 w
.reserve(header_len
);
539 "{vis}{constness}{asyncness}{unsafety}{abi}fn \
540 {name}{generics}{decl}{notable_traits}{where_clause}",
542 constness
= constness
,
543 asyncness
= asyncness
,
547 generics
= f
.generics
.print(cx
),
548 where_clause
= print_where_clause(&f
.generics
, cx
, 0, Ending
::Newline
),
549 decl
= f
.decl
.full_print(header_len
, 0, cx
),
550 notable_traits
= notable_traits
.unwrap_or_default(),
554 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
557 fn item_trait(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, t
: &clean
::Trait
) {
559 let bounds
= bounds(&t
.bounds
, false, cx
);
560 let required_types
= t
.items
.iter().filter(|m
| m
.is_ty_associated_type()).collect
::<Vec
<_
>>();
561 let provided_types
= t
.items
.iter().filter(|m
| m
.is_associated_type()).collect
::<Vec
<_
>>();
562 let required_consts
= t
.items
.iter().filter(|m
| m
.is_ty_associated_const()).collect
::<Vec
<_
>>();
563 let provided_consts
= t
.items
.iter().filter(|m
| m
.is_associated_const()).collect
::<Vec
<_
>>();
564 let required_methods
= t
.items
.iter().filter(|m
| m
.is_ty_method()).collect
::<Vec
<_
>>();
565 let provided_methods
= t
.items
.iter().filter(|m
| m
.is_method()).collect
::<Vec
<_
>>();
566 let count_types
= required_types
.len() + provided_types
.len();
567 let count_consts
= required_consts
.len() + provided_consts
.len();
568 let count_methods
= required_methods
.len() + provided_methods
.len();
569 let must_implement_one_of_functions
= tcx
.trait_def(t
.def_id
).must_implement_one_of
.clone();
571 // Output the trait definition
572 wrap_into_item_decl(w
, |w
| {
573 wrap_item(w
, "trait", |w
| {
574 render_attributes_in_pre(w
, it
, "");
577 "{}{}{}trait {}{}{}",
578 visibility_print_with_space(it
.visibility(tcx
), it
.item_id
, cx
),
579 t
.unsafety(tcx
).print_with_space(),
580 if t
.is_auto(tcx
) { "auto " }
else { "" }
,
582 t
.generics
.print(cx
),
586 if !t
.generics
.where_predicates
.is_empty() {
587 write
!(w
, "{}", print_where_clause(&t
.generics
, cx
, 0, Ending
::Newline
));
592 if t
.items
.is_empty() {
595 // FIXME: we should be using a derived_id for the Anchors here
597 let mut toggle
= false;
599 // If there are too many associated types, hide _everything_
600 if should_hide_fields(count_types
) {
605 "{} associated items",
606 count_types
+ count_consts
+ count_methods
610 for types
in [&required_types
, &provided_types
] {
615 AssocItemLink
::Anchor(None
),
623 // If there are too many associated constants, hide everything after them
624 // We also do this if the types + consts is large because otherwise we could
625 // render a bunch of types and _then_ a bunch of consts just because both were
626 // _just_ under the limit
627 if !toggle
&& should_hide_fields(count_types
+ count_consts
) {
632 "{} associated constant{} and {} method{}",
634 pluralize(count_consts
),
636 pluralize(count_methods
),
640 if count_types
!= 0 && (count_consts
!= 0 || count_methods
!= 0) {
643 for consts
in [&required_consts
, &provided_consts
] {
648 AssocItemLink
::Anchor(None
),
656 if !toggle
&& should_hide_fields(count_methods
) {
658 toggle_open(w
, format_args
!("{} methods", count_methods
));
660 if count_consts
!= 0 && count_methods
!= 0 {
663 for (pos
, m
) in required_methods
.iter().enumerate() {
667 AssocItemLink
::Anchor(None
),
674 if pos
< required_methods
.len() - 1 {
675 w
.write_str("<span class=\"item-spacer\"></span>");
678 if !required_methods
.is_empty() && !provided_methods
.is_empty() {
681 for (pos
, m
) in provided_methods
.iter().enumerate() {
685 AssocItemLink
::Anchor(None
),
691 clean
::MethodItem(ref inner
, _
)
692 if !inner
.generics
.where_predicates
.is_empty() =>
694 w
.write_str(",\n { ... }\n");
697 w
.write_str(" { ... }\n");
701 if pos
< provided_methods
.len() - 1 {
702 w
.write_str("<span class=\"item-spacer\"></span>");
713 // Trait documentation
714 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
716 fn write_small_section_header(w
: &mut Buffer
, id
: &str, title
: &str, extra_content
: &str) {
719 "<h2 id=\"{0}\" class=\"small-section-header\">\
720 {1}<a href=\"#{0}\" class=\"anchor\">§</a>\
722 id
, title
, extra_content
726 fn trait_item(w
: &mut Buffer
, cx
: &mut Context
<'_
>, m
: &clean
::Item
, t
: &clean
::Item
) {
727 let name
= m
.name
.unwrap();
728 info
!("Documenting {} on {:?}", name
, t
.name
);
729 let item_type
= m
.type_();
730 let id
= cx
.derive_id(format
!("{}.{}", item_type
, name
));
731 let mut content
= Buffer
::empty_from(w
);
732 document(&mut content
, cx
, m
, Some(t
), HeadingOffset
::H5
);
733 let toggled
= !content
.is_empty();
735 write
!(w
, "<details class=\"rustdoc-toggle method-toggle\" open><summary>");
737 write
!(w
, "<section id=\"{}\" class=\"method has-srclink\">", id
);
738 render_rightside(w
, cx
, m
, t
, RenderMode
::Normal
);
739 write
!(w
, "<h4 class=\"code-header\">");
743 AssocItemLink
::Anchor(Some(&id
)),
748 w
.write_str("</h4>");
749 w
.write_str("</section>");
751 write
!(w
, "</summary>");
752 w
.push_buffer(content
);
753 write
!(w
, "</details>");
757 if !required_types
.is_empty() {
758 write_small_section_header(
760 "required-associated-types",
761 "Required Associated Types",
762 "<div class=\"methods\">",
764 for t
in required_types
{
765 trait_item(w
, cx
, t
, it
);
767 w
.write_str("</div>");
769 if !provided_types
.is_empty() {
770 write_small_section_header(
772 "provided-associated-types",
773 "Provided Associated Types",
774 "<div class=\"methods\">",
776 for t
in provided_types
{
777 trait_item(w
, cx
, t
, it
);
779 w
.write_str("</div>");
782 if !required_consts
.is_empty() {
783 write_small_section_header(
785 "required-associated-consts",
786 "Required Associated Constants",
787 "<div class=\"methods\">",
789 for t
in required_consts
{
790 trait_item(w
, cx
, t
, it
);
792 w
.write_str("</div>");
794 if !provided_consts
.is_empty() {
795 write_small_section_header(
797 "provided-associated-consts",
798 "Provided Associated Constants",
799 "<div class=\"methods\">",
801 for t
in provided_consts
{
802 trait_item(w
, cx
, t
, it
);
804 w
.write_str("</div>");
807 // Output the documentation for each function individually
808 if !required_methods
.is_empty() || must_implement_one_of_functions
.is_some() {
809 write_small_section_header(
813 "<div class=\"methods\">",
816 if let Some(list
) = must_implement_one_of_functions
.as_deref() {
819 "<div class=\"stab must_implement\">At least one of the `{}` methods is required.</div>",
820 list
.iter().join("`, `")
824 for m
in required_methods
{
825 trait_item(w
, cx
, m
, it
);
827 w
.write_str("</div>");
829 if !provided_methods
.is_empty() {
830 write_small_section_header(
834 "<div class=\"methods\">",
836 for m
in provided_methods
{
837 trait_item(w
, cx
, m
, it
);
839 w
.write_str("</div>");
842 // If there are methods directly on this trait object, render them here.
843 render_assoc_items(w
, cx
, it
, it
.item_id
.expect_def_id(), AssocItemRender
::All
);
845 let cloned_shared
= Rc
::clone(&cx
.shared
);
846 let cache
= &cloned_shared
.cache
;
847 let mut extern_crates
= FxHashSet
::default();
848 if let Some(implementors
) = cache
.implementors
.get(&it
.item_id
.expect_def_id()) {
849 // The DefId is for the first Type found with that name. The bool is
850 // if any Types with the same name but different DefId have been found.
851 let mut implementor_dups
: FxHashMap
<Symbol
, (DefId
, bool
)> = FxHashMap
::default();
852 for implementor
in implementors
{
853 if let Some(did
) = implementor
.inner_impl().for_
.without_borrowed_ref().def_id(cache
) &&
855 extern_crates
.insert(did
.krate
);
857 match implementor
.inner_impl().for_
.without_borrowed_ref() {
858 clean
::Type
::Path { ref path }
if !path
.is_assoc_ty() => {
859 let did
= path
.def_id();
860 let &mut (prev_did
, ref mut has_duplicates
) =
861 implementor_dups
.entry(path
.last()).or_insert((did
, false));
863 *has_duplicates
= true;
870 let (local
, foreign
) =
871 implementors
.iter().partition
::<Vec
<_
>, _
>(|i
| i
.is_on_local_type(cx
));
873 let (mut synthetic
, mut concrete
): (Vec
<&&Impl
>, Vec
<&&Impl
>) =
874 local
.iter().partition(|i
| i
.inner_impl().kind
.is_auto());
876 synthetic
.sort_by(|a
, b
| compare_impl(a
, b
, cx
));
877 concrete
.sort_by(|a
, b
| compare_impl(a
, b
, cx
));
879 if !foreign
.is_empty() {
880 write_small_section_header(w
, "foreign-impls", "Implementations on Foreign Types", "");
882 for implementor
in foreign
{
883 let provided_methods
= implementor
.inner_impl().provided_trait_methods(cx
.tcx());
885 AssocItemLink
::GotoSource(implementor
.impl_item
.item_id
, &provided_methods
);
895 ImplRenderingParameters
{
896 show_def_docs
: false,
897 show_default_items
: false,
898 show_non_assoc_items
: true,
899 toggle_open_by_default
: false,
905 write_small_section_header(
909 "<div id=\"implementors-list\">",
911 for implementor
in concrete
{
912 render_implementor(cx
, implementor
, it
, w
, &implementor_dups
, &[]);
914 w
.write_str("</div>");
916 if t
.is_auto(cx
.tcx()) {
917 write_small_section_header(
919 "synthetic-implementors",
921 "<div id=\"synthetic-implementors-list\">",
923 for implementor
in synthetic
{
930 &collect_paths_for_type(implementor
.inner_impl().for_
.clone(), cache
),
933 w
.write_str("</div>");
936 // even without any implementations to write in, we still want the heading and list, so the
937 // implementors javascript file pulled in below has somewhere to write the impls into
938 write_small_section_header(
942 "<div id=\"implementors-list\"></div>",
945 if t
.is_auto(cx
.tcx()) {
946 write_small_section_header(
948 "synthetic-implementors",
950 "<div id=\"synthetic-implementors-list\"></div>",
955 // Include implementors in crates that depend on the current crate.
957 // This is complicated by the way rustdoc is invoked, which is basically
958 // the same way rustc is invoked: it gets called, one at a time, for each
959 // crate. When building the rustdocs for the current crate, rustdoc can
960 // see crate metadata for its dependencies, but cannot see metadata for its
963 // To make this work, we generate a "hook" at this stage, and our
964 // dependents can "plug in" to it when they build. For simplicity's sake,
965 // it's [JSONP]: a JavaScript file with the data we need (and can parse),
966 // surrounded by a tiny wrapper that the Rust side ignores, but allows the
967 // JavaScript side to include without having to worry about Same Origin
968 // Policy. The code for *that* is in `write_shared.rs`.
970 // This is further complicated by `#[doc(inline)]`. We want all copies
971 // of an inlined trait to reference the same JS file, to address complex
972 // dependency graphs like this one (lower crates depend on higher crates):
975 // --------------------------------------------
976 // | crate A: trait Foo |
977 // --------------------------------------------
979 // -------------------------------- |
980 // | crate B: impl A::Foo for Bar | |
981 // -------------------------------- |
983 // ---------------------------------------------
984 // | crate C: #[doc(inline)] use A::Foo as Baz |
985 // | impl Baz for Quux |
986 // ---------------------------------------------
989 // Basically, we want `C::Baz` and `A::Foo` to show the same set of
990 // impls, which is easier if they both treat `/implementors/A/trait.Foo.js`
991 // as the Single Source of Truth.
993 // We also want the `impl Baz for Quux` to be written to
994 // `trait.Foo.js`. However, when we generate plain HTML for `C::Baz`,
995 // we're going to want to generate plain HTML for `impl Baz for Quux` too,
996 // because that'll load faster, and it's better for SEO. And we don't want
997 // the same impl to show up twice on the same page.
999 // To make this work, the implementors JS file has a structure kinda
1004 // "B": {"impl A::Foo for Bar"},
1005 // "C": {"impl Baz for Quux"},
1009 // First of all, this means we can rebuild a crate, and it'll replace its own
1010 // data if something changes. That is, `rustdoc` is idempotent. The other
1011 // advantage is that we can list the crates that get included in the HTML,
1012 // and ignore them when doing the JavaScript-based part of rendering.
1013 // So C's HTML will have something like this:
1016 // <script src="/implementors/A/trait.Foo.js"
1017 // data-ignore-extern-crates="A,B" async></script>
1020 // And, when the JS runs, anything in data-ignore-extern-crates is known
1021 // to already be in the HTML, and will be ignored.
1023 // [JSONP]: https://en.wikipedia.org/wiki/JSONP
1024 let mut js_src_path
: UrlPartsBuilder
= std
::iter
::repeat("..")
1025 .take(cx
.current
.len())
1026 .chain(std
::iter
::once("implementors"))
1028 if let Some(did
) = it
.item_id
.as_def_id() &&
1029 let get_extern
= { || cache.external_paths.get(&did).map(|s| s.0.clone()) }
&&
1030 let Some(fqp
) = cache
.exact_paths
.get(&did
).cloned().or_else(get_extern
) {
1031 js_src_path
.extend(fqp
[..fqp
.len() - 1].iter().copied());
1032 js_src_path
.push_fmt(format_args
!("{}.{}.js", it
.type_(), fqp
.last().unwrap()));
1034 js_src_path
.extend(cx
.current
.iter().copied());
1035 js_src_path
.push_fmt(format_args
!("{}.{}.js", it
.type_(), it
.name
.unwrap()));
1037 let extern_crates
= extern_crates
1039 .map(|cnum
| tcx
.crate_name(cnum
).to_string())
1040 .collect
::<Vec
<_
>>()
1042 let (extern_before
, extern_after
) =
1043 if extern_crates
.is_empty() { ("", "") }
else { (" data-ignore-extern-crates=\"", "\"") }
;
1046 "<script src=\"{src}\"{extern_before}{extern_crates}{extern_after} async></script>",
1047 src
= js_src_path
.finish(),
1051 fn item_trait_alias(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, t
: &clean
::TraitAlias
) {
1052 wrap_into_item_decl(w
, |w
| {
1053 wrap_item(w
, "trait-alias", |w
| {
1054 render_attributes_in_pre(w
, it
, "");
1057 "trait {}{}{} = {};",
1059 t
.generics
.print(cx
),
1060 print_where_clause(&t
.generics
, cx
, 0, Ending
::Newline
),
1061 bounds(&t
.bounds
, true, cx
)
1066 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1068 // Render any items associated directly to this alias, as otherwise they
1069 // won't be visible anywhere in the docs. It would be nice to also show
1070 // associated items from the aliased type (see discussion in #32077), but
1071 // we need #14072 to make sense of the generics.
1072 render_assoc_items(w
, cx
, it
, it
.item_id
.expect_def_id(), AssocItemRender
::All
)
1075 fn item_opaque_ty(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, t
: &clean
::OpaqueTy
) {
1076 wrap_into_item_decl(w
, |w
| {
1077 wrap_item(w
, "opaque", |w
| {
1078 render_attributes_in_pre(w
, it
, "");
1081 "type {}{}{where_clause} = impl {bounds};",
1083 t
.generics
.print(cx
),
1084 where_clause
= print_where_clause(&t
.generics
, cx
, 0, Ending
::Newline
),
1085 bounds
= bounds(&t
.bounds
, false, cx
),
1090 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1092 // Render any items associated directly to this alias, as otherwise they
1093 // won't be visible anywhere in the docs. It would be nice to also show
1094 // associated items from the aliased type (see discussion in #32077), but
1095 // we need #14072 to make sense of the generics.
1096 render_assoc_items(w
, cx
, it
, it
.item_id
.expect_def_id(), AssocItemRender
::All
)
1099 fn item_typedef(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, t
: &clean
::Typedef
) {
1100 fn write_content(w
: &mut Buffer
, cx
: &Context
<'_
>, it
: &clean
::Item
, t
: &clean
::Typedef
) {
1101 wrap_item(w
, "typedef", |w
| {
1102 render_attributes_in_pre(w
, it
, "");
1103 write
!(w
, "{}", visibility_print_with_space(it
.visibility(cx
.tcx()), it
.item_id
, cx
));
1106 "type {}{}{where_clause} = {type_};",
1108 t
.generics
.print(cx
),
1109 where_clause
= print_where_clause(&t
.generics
, cx
, 0, Ending
::Newline
),
1110 type_
= t
.type_
.print(cx
),
1115 wrap_into_item_decl(w
, |w
| write_content(w
, cx
, it
, t
));
1117 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1119 let def_id
= it
.item_id
.expect_def_id();
1120 // Render any items associated directly to this alias, as otherwise they
1121 // won't be visible anywhere in the docs. It would be nice to also show
1122 // associated items from the aliased type (see discussion in #32077), but
1123 // we need #14072 to make sense of the generics.
1124 render_assoc_items(w
, cx
, it
, def_id
, AssocItemRender
::All
);
1125 document_type_layout(w
, cx
, def_id
);
1128 fn item_union(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, s
: &clean
::Union
) {
1129 wrap_into_item_decl(w
, |w
| {
1130 wrap_item(w
, "union", |w
| {
1131 render_attributes_in_pre(w
, it
, "");
1132 render_union(w
, it
, Some(&s
.generics
), &s
.fields
, "", cx
);
1136 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1141 .filter_map(|f
| match *f
.kind
{
1142 clean
::StructFieldItem(ref ty
) => Some((f
, ty
)),
1146 if fields
.peek().is_some() {
1149 "<h2 id=\"fields\" class=\"fields small-section-header\">\
1150 Fields<a href=\"#fields\" class=\"anchor\">§</a>\
1153 for (field
, ty
) in fields
{
1154 let name
= field
.name
.expect("union field name");
1155 let id
= format
!("{}.{}", ItemType
::StructField
, name
);
1158 "<span id=\"{id}\" class=\"{shortty} small-section-header\">\
1159 <a href=\"#{id}\" class=\"anchor field\">§</a>\
1160 <code>{name}: {ty}</code>\
1164 shortty
= ItemType
::StructField
,
1167 if let Some(stability_class
) = field
.stability_class(cx
.tcx()) {
1168 write
!(w
, "<span class=\"stab {stab}\"></span>", stab
= stability_class
);
1170 document(w
, cx
, field
, Some(it
), HeadingOffset
::H3
);
1173 let def_id
= it
.item_id
.expect_def_id();
1174 render_assoc_items(w
, cx
, it
, def_id
, AssocItemRender
::All
);
1175 document_type_layout(w
, cx
, def_id
);
1178 fn print_tuple_struct_fields(w
: &mut Buffer
, cx
: &Context
<'_
>, s
: &[clean
::Item
]) {
1179 for (i
, ty
) in s
.iter().enumerate() {
1181 w
.write_str(", ");
1184 clean
::StrippedItem(box clean
::StructFieldItem(_
)) => w
.write_str("_"),
1185 clean
::StructFieldItem(ref ty
) => write
!(w
, "{}", ty
.print(cx
)),
1186 _
=> unreachable
!(),
1191 fn item_enum(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, e
: &clean
::Enum
) {
1193 let count_variants
= e
.variants().count();
1194 wrap_into_item_decl(w
, |w
| {
1195 wrap_item(w
, "enum", |w
| {
1196 render_attributes_in_pre(w
, it
, "");
1200 visibility_print_with_space(it
.visibility(tcx
), it
.item_id
, cx
),
1202 e
.generics
.print(cx
),
1204 if !print_where_clause_and_check(w
, &e
.generics
, cx
) {
1205 // If there wasn't a `where` clause, we add a whitespace.
1209 let variants_stripped
= e
.has_stripped_entries();
1210 if count_variants
== 0 && !variants_stripped
{
1214 let toggle
= should_hide_fields(count_variants
);
1216 toggle_open(w
, format_args
!("{} variants", count_variants
));
1218 for v
in e
.variants() {
1220 let name
= v
.name
.unwrap();
1222 clean
::VariantItem(ref var
) => match var
{
1223 // FIXME(#101337): Show discriminant
1224 clean
::Variant
::CLike(..) => write
!(w
, "{}", name
),
1225 clean
::Variant
::Tuple(ref s
) => {
1226 write
!(w
, "{}(", name
);
1227 print_tuple_struct_fields(w
, cx
, s
);
1230 clean
::Variant
::Struct(ref s
) => {
1243 _
=> unreachable
!(),
1248 if variants_stripped
{
1249 w
.write_str(" // some variants omitted\n");
1259 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1261 if count_variants
!= 0 {
1264 "<h2 id=\"variants\" class=\"variants small-section-header\">\
1265 Variants{}<a href=\"#variants\" class=\"anchor\">§</a>\
1267 document_non_exhaustive_header(it
)
1269 document_non_exhaustive(w
, it
);
1270 write
!(w
, "<div class=\"variants\">");
1271 for variant
in e
.variants() {
1272 let id
= cx
.derive_id(format
!("{}.{}", ItemType
::Variant
, variant
.name
.unwrap()));
1275 "<section id=\"{id}\" class=\"variant\">\
1276 <a href=\"#{id}\" class=\"anchor\">§</a>",
1279 render_stability_since_raw_with_extra(
1281 variant
.stable_since(tcx
),
1282 variant
.const_stability(tcx
),
1283 it
.stable_since(tcx
),
1284 it
.const_stable_since(tcx
),
1287 write
!(w
, "<h3 class=\"code-header\">{name}", name
= variant
.name
.unwrap());
1288 if let clean
::VariantItem(clean
::Variant
::Tuple(ref s
)) = *variant
.kind
{
1290 print_tuple_struct_fields(w
, cx
, s
);
1293 w
.write_str("</h3></section>");
1295 use crate::clean
::Variant
;
1297 let heading_and_fields
= match &*variant
.kind
{
1298 clean
::VariantItem(Variant
::Struct(s
)) => Some(("Fields", &s
.fields
)),
1299 // Documentation on tuple variant fields is rare, so to reduce noise we only emit
1300 // the section if at least one field is documented.
1301 clean
::VariantItem(Variant
::Tuple(fields
))
1302 if fields
.iter().any(|f
| f
.doc_value().is_some()) =>
1304 Some(("Tuple Fields", fields
))
1309 if let Some((heading
, fields
)) = heading_and_fields
{
1311 cx
.derive_id(format
!("{}.{}.fields", ItemType
::Variant
, variant
.name
.unwrap()));
1312 write
!(w
, "<div class=\"sub-variant\" id=\"{id}\">", id
= variant_id
);
1313 write
!(w
, "<h4>{heading}</h4>", heading
= heading
);
1314 document_non_exhaustive(w
, variant
);
1315 for field
in fields
{
1317 clean
::StrippedItem(box clean
::StructFieldItem(_
)) => {}
1318 clean
::StructFieldItem(ref ty
) => {
1319 let id
= cx
.derive_id(format
!(
1320 "variant.{}.field.{}",
1321 variant
.name
.unwrap(),
1326 "<div class=\"sub-variant-field\">\
1327 <span id=\"{id}\" class=\"small-section-header\">\
1328 <a href=\"#{id}\" class=\"anchor field\">§</a>\
1329 <code>{f}: {t}</code>\
1332 f
= field
.name
.unwrap(),
1335 document(w
, cx
, field
, Some(variant
), HeadingOffset
::H5
);
1336 write
!(w
, "</div>");
1338 _
=> unreachable
!(),
1341 w
.write_str("</div>");
1344 document(w
, cx
, variant
, Some(it
), HeadingOffset
::H4
);
1346 write
!(w
, "</div>");
1348 let def_id
= it
.item_id
.expect_def_id();
1349 render_assoc_items(w
, cx
, it
, def_id
, AssocItemRender
::All
);
1350 document_type_layout(w
, cx
, def_id
);
1353 fn item_macro(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, t
: &clean
::Macro
) {
1354 wrap_into_item_decl(w
, |w
| {
1355 highlight
::render_macro_with_highlighting(&t
.source
, w
);
1357 document(w
, cx
, it
, None
, HeadingOffset
::H2
)
1360 fn item_proc_macro(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, m
: &clean
::ProcMacro
) {
1361 wrap_into_item_decl(w
, |w
| {
1362 let name
= it
.name
.expect("proc-macros always have names");
1364 MacroKind
::Bang
=> {
1365 wrap_item(w
, "macro", |w
| {
1366 write
!(w
, "{}!() {{ /* proc-macro */ }}", name
);
1369 MacroKind
::Attr
=> {
1370 wrap_item(w
, "attr", |w
| {
1371 write
!(w
, "#[{}]", name
);
1374 MacroKind
::Derive
=> {
1375 wrap_item(w
, "derive", |w
| {
1376 write
!(w
, "#[derive({})]", name
);
1377 if !m
.helpers
.is_empty() {
1378 w
.push_str("\n{\n");
1379 w
.push_str(" // Attributes available to this derive:\n");
1380 for attr
in &m
.helpers
{
1381 writeln
!(w
, " #[{}]", attr
);
1389 document(w
, cx
, it
, None
, HeadingOffset
::H2
)
1392 fn item_primitive(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
) {
1393 let def_id
= it
.item_id
.expect_def_id();
1394 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1395 if it
.name
.map(|n
| n
.as_str() != "reference").unwrap_or(false) {
1396 render_assoc_items(w
, cx
, it
, def_id
, AssocItemRender
::All
);
1398 // We handle the "reference" primitive type on its own because we only want to list
1399 // implementations on generic types.
1400 let shared
= Rc
::clone(&cx
.shared
);
1401 let (concrete
, synthetic
, blanket_impl
) = get_filtered_impls_for_reference(&shared
, it
);
1403 render_all_impls(w
, cx
, it
, &concrete
, &synthetic
, &blanket_impl
);
1407 fn item_constant(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, c
: &clean
::Constant
) {
1408 wrap_into_item_decl(w
, |w
| {
1409 wrap_item(w
, "const", |w
| {
1411 render_attributes_in_code(w
, it
);
1415 "{vis}const {name}: {typ}",
1416 vis
= visibility_print_with_space(it
.visibility(tcx
), it
.item_id
, cx
),
1417 name
= it
.name
.unwrap(),
1418 typ
= c
.type_
.print(cx
),
1421 // FIXME: The code below now prints
1422 // ` = _; // 100i32`
1423 // if the expression is
1425 // which looks just wrong.
1430 let value
= c
.value(tcx
);
1431 let is_literal
= c
.is_literal(tcx
);
1432 let expr
= c
.expr(tcx
);
1433 if value
.is_some() || is_literal
{
1434 write
!(w
, " = {expr};", expr
= Escape(&expr
));
1440 if let Some(value
) = &value
{
1441 let value_lowercase
= value
.to_lowercase();
1442 let expr_lowercase
= expr
.to_lowercase();
1444 if value_lowercase
!= expr_lowercase
1445 && value_lowercase
.trim_end_matches("i32") != expr_lowercase
1447 write
!(w
, " // {value}", value
= Escape(value
));
1454 document(w
, cx
, it
, None
, HeadingOffset
::H2
)
1457 fn item_struct(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, s
: &clean
::Struct
) {
1458 wrap_into_item_decl(w
, |w
| {
1459 wrap_item(w
, "struct", |w
| {
1460 render_attributes_in_code(w
, it
);
1461 render_struct(w
, it
, Some(&s
.generics
), s
.ctor_kind
, &s
.fields
, "", true, cx
);
1465 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1470 .filter_map(|f
| match *f
.kind
{
1471 clean
::StructFieldItem(ref ty
) => Some((f
, ty
)),
1475 if let None
| Some(CtorKind
::Fn
) = s
.ctor_kind
{
1476 if fields
.peek().is_some() {
1479 "<h2 id=\"fields\" class=\"fields small-section-header\">\
1480 {}{}<a href=\"#fields\" class=\"anchor\">§</a>\
1482 if s
.ctor_kind
.is_none() { "Fields" }
else { "Tuple Fields" }
,
1483 document_non_exhaustive_header(it
)
1485 document_non_exhaustive(w
, it
);
1486 for (index
, (field
, ty
)) in fields
.enumerate() {
1488 field
.name
.map_or_else(|| index
.to_string(), |sym
| sym
.as_str().to_string());
1489 let id
= cx
.derive_id(format
!("{}.{}", ItemType
::StructField
, field_name
));
1492 "<span id=\"{id}\" class=\"{item_type} small-section-header\">\
1493 <a href=\"#{id}\" class=\"anchor field\">§</a>\
1494 <code>{name}: {ty}</code>\
1496 item_type
= ItemType
::StructField
,
1501 document(w
, cx
, field
, Some(it
), HeadingOffset
::H3
);
1505 let def_id
= it
.item_id
.expect_def_id();
1506 render_assoc_items(w
, cx
, it
, def_id
, AssocItemRender
::All
);
1507 document_type_layout(w
, cx
, def_id
);
1510 fn item_static(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
, s
: &clean
::Static
) {
1511 wrap_into_item_decl(w
, |w
| {
1512 wrap_item(w
, "static", |w
| {
1513 render_attributes_in_code(w
, it
);
1516 "{vis}static {mutability}{name}: {typ}",
1517 vis
= visibility_print_with_space(it
.visibility(cx
.tcx()), it
.item_id
, cx
),
1518 mutability
= s
.mutability
.print_with_space(),
1519 name
= it
.name
.unwrap(),
1520 typ
= s
.type_
.print(cx
)
1524 document(w
, cx
, it
, None
, HeadingOffset
::H2
)
1527 fn item_foreign_type(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
) {
1528 wrap_into_item_decl(w
, |w
| {
1529 wrap_item(w
, "foreigntype", |w
| {
1530 w
.write_str("extern {\n");
1531 render_attributes_in_code(w
, it
);
1535 visibility_print_with_space(it
.visibility(cx
.tcx()), it
.item_id
, cx
),
1541 document(w
, cx
, it
, None
, HeadingOffset
::H2
);
1543 render_assoc_items(w
, cx
, it
, it
.item_id
.expect_def_id(), AssocItemRender
::All
)
1546 fn item_keyword(w
: &mut Buffer
, cx
: &mut Context
<'_
>, it
: &clean
::Item
) {
1547 document(w
, cx
, it
, None
, HeadingOffset
::H2
)
1550 /// Compare two strings treating multi-digit numbers as single units (i.e. natural sort order).
1551 pub(crate) fn compare_names(mut lhs
: &str, mut rhs
: &str) -> Ordering
{
1552 /// Takes a non-numeric and a numeric part from the given &str.
1553 fn take_parts
<'a
>(s
: &mut &'a
str) -> (&'a
str, &'a
str) {
1554 let i
= s
.find(|c
: char| c
.is_ascii_digit());
1555 let (a
, b
) = s
.split_at(i
.unwrap_or(s
.len()));
1556 let i
= b
.find(|c
: char| !c
.is_ascii_digit());
1557 let (b
, c
) = b
.split_at(i
.unwrap_or(b
.len()));
1562 while !lhs
.is_empty() || !rhs
.is_empty() {
1563 let (la
, lb
) = take_parts(&mut lhs
);
1564 let (ra
, rb
) = take_parts(&mut rhs
);
1565 // First process the non-numeric part.
1567 Ordering
::Equal
=> (),
1570 // Then process the numeric part, if both sides have one (and they fit in a u64).
1571 if let (Ok(ln
), Ok(rn
)) = (lb
.parse
::<u64>(), rb
.parse
::<u64>()) {
1573 Ordering
::Equal
=> (),
1577 // Then process the numeric part again, but this time as strings.
1579 Ordering
::Equal
=> (),
1587 pub(super) fn full_path(cx
: &Context
<'_
>, item
: &clean
::Item
) -> String
{
1588 let mut s
= join_with_double_colon(&cx
.current
);
1590 s
.push_str(item
.name
.unwrap().as_str());
1594 pub(super) fn item_path(ty
: ItemType
, name
: &str) -> String
{
1596 ItemType
::Module
=> format
!("{}index.html", ensure_trailing_slash(name
)),
1597 _
=> format
!("{}.{}.html", ty
, name
),
1601 fn bounds(t_bounds
: &[clean
::GenericBound
], trait_alias
: bool
, cx
: &Context
<'_
>) -> String
{
1602 let mut bounds
= String
::new();
1603 if !t_bounds
.is_empty() {
1605 bounds
.push_str(": ");
1607 for (i
, p
) in t_bounds
.iter().enumerate() {
1609 bounds
.push_str(" + ");
1611 bounds
.push_str(&p
.print(cx
).to_string());
1617 fn wrap_into_item_decl
<F
>(w
: &mut Buffer
, f
: F
)
1619 F
: FnOnce(&mut Buffer
),
1621 w
.write_str("<div class=\"item-decl\">");
1623 w
.write_str("</div>")
1626 fn wrap_item
<F
>(w
: &mut Buffer
, item_name
: &str, f
: F
)
1628 F
: FnOnce(&mut Buffer
),
1630 w
.write_fmt(format_args
!("<pre class=\"rust {}\"><code>", item_name
));
1632 w
.write_str("</code></pre>");
1635 fn compare_impl
<'a
, 'b
>(lhs
: &'a
&&Impl
, rhs
: &'b
&&Impl
, cx
: &Context
<'_
>) -> Ordering
{
1636 let lhss
= format
!("{}", lhs
.inner_impl().print(false, cx
));
1637 let rhss
= format
!("{}", rhs
.inner_impl().print(false, cx
));
1639 // lhs and rhs are formatted as HTML, which may be unnecessary
1640 compare_names(&lhss
, &rhss
)
1643 fn render_implementor(
1644 cx
: &mut Context
<'_
>,
1646 trait_
: &clean
::Item
,
1648 implementor_dups
: &FxHashMap
<Symbol
, (DefId
, bool
)>,
1651 // If there's already another implementor that has the same abridged name, use the
1652 // full path, for example in `std::iter::ExactSizeIterator`
1653 let use_absolute
= match implementor
.inner_impl().for_
{
1654 clean
::Type
::Path { ref path, .. }
1655 | clean
::BorrowedRef { type_: box clean::Type::Path { ref path, .. }
, .. }
1656 if !path
.is_assoc_ty() =>
1658 implementor_dups
[&path
.last()].1
1667 AssocItemLink
::Anchor(None
),
1671 ImplRenderingParameters
{
1672 show_def_docs
: false,
1673 show_default_items
: false,
1674 show_non_assoc_items
: false,
1675 toggle_open_by_default
: false,
1683 g
: Option
<&clean
::Generics
>,
1684 fields
: &[clean
::Item
],
1692 visibility_print_with_space(it
.visibility(tcx
), it
.item_id
, cx
),
1696 let where_displayed
= g
1698 write
!(w
, "{}", g
.print(cx
));
1699 print_where_clause_and_check(w
, g
, cx
)
1703 // If there wasn't a `where` clause, we add a whitespace.
1704 if !where_displayed
{
1708 write
!(w
, "{{\n{}", tab
);
1710 fields
.iter().filter(|f
| matches
!(*f
.kind
, clean
::StructFieldItem(..))).count();
1711 let toggle
= should_hide_fields(count_fields
);
1713 toggle_open(w
, format_args
!("{} fields", count_fields
));
1716 for field
in fields
{
1717 if let clean
::StructFieldItem(ref ty
) = *field
.kind
{
1721 visibility_print_with_space(field
.visibility(tcx
), field
.item_id
, cx
),
1722 field
.name
.unwrap(),
1729 if it
.has_stripped_entries().unwrap() {
1730 write
!(w
, " /* private fields */\n{}", tab
);
1741 g
: Option
<&clean
::Generics
>,
1742 ty
: Option
<CtorKind
>,
1743 fields
: &[clean
::Item
],
1752 visibility_print_with_space(it
.visibility(tcx
), it
.item_id
, cx
),
1753 if structhead { "struct " }
else { "" }
,
1756 if let Some(g
) = g
{
1757 write
!(w
, "{}", g
.print(cx
))
1761 let where_diplayed
= g
.map(|g
| print_where_clause_and_check(w
, g
, cx
)).unwrap_or(false);
1763 // If there wasn't a `where` clause, we add a whitespace.
1764 if !where_diplayed
{
1770 fields
.iter().filter(|f
| matches
!(*f
.kind
, clean
::StructFieldItem(..))).count();
1771 let has_visible_fields
= count_fields
> 0;
1772 let toggle
= should_hide_fields(count_fields
);
1774 toggle_open(w
, format_args
!("{} fields", count_fields
));
1776 for field
in fields
{
1777 if let clean
::StructFieldItem(ref ty
) = *field
.kind
{
1782 visibility_print_with_space(field
.visibility(tcx
), field
.item_id
, cx
),
1783 field
.name
.unwrap(),
1789 if has_visible_fields
{
1790 if it
.has_stripped_entries().unwrap() {
1791 write
!(w
, "\n{} /* private fields */", tab
);
1793 write
!(w
, "\n{}", tab
);
1794 } else if it
.has_stripped_entries().unwrap() {
1795 write
!(w
, " /* private fields */ ");
1802 Some(CtorKind
::Fn
) => {
1804 for (i
, field
) in fields
.iter().enumerate() {
1809 clean
::StrippedItem(box clean
::StructFieldItem(..)) => write
!(w
, "_"),
1810 clean
::StructFieldItem(ref ty
) => {
1814 visibility_print_with_space(field
.visibility(tcx
), field
.item_id
, cx
),
1818 _
=> unreachable
!(),
1822 if let Some(g
) = g
{
1823 write
!(w
, "{}", print_where_clause(g
, cx
, 0, Ending
::NoNewline
));
1825 // We only want a ";" when we are displaying a tuple struct, not a variant tuple struct.
1830 Some(CtorKind
::Const
) => {
1831 // Needed for PhantomData.
1832 if let Some(g
) = g
{
1833 write
!(w
, "{}", print_where_clause(g
, cx
, 0, Ending
::NoNewline
));
1840 fn document_non_exhaustive_header(item
: &clean
::Item
) -> &str {
1841 if item
.is_non_exhaustive() { " (Non-exhaustive)" }
else { "" }
1844 fn document_non_exhaustive(w
: &mut Buffer
, item
: &clean
::Item
) {
1845 if item
.is_non_exhaustive() {
1848 "<details class=\"rustdoc-toggle non-exhaustive\">\
1849 <summary class=\"hideme\"><span>{}</span></summary>\
1850 <div class=\"docblock\">",
1852 if item
.is_struct() {
1853 "This struct is marked as non-exhaustive"
1854 } else if item
.is_enum() {
1855 "This enum is marked as non-exhaustive"
1856 } else if item
.is_variant() {
1857 "This variant is marked as non-exhaustive"
1859 "This type is marked as non-exhaustive"
1864 if item
.is_struct() {
1866 "Non-exhaustive structs could have additional fields added in future. \
1867 Therefore, non-exhaustive structs cannot be constructed in external crates \
1868 using the traditional <code>Struct { .. }</code> syntax; cannot be \
1869 matched against without a wildcard <code>..</code>; and \
1870 struct update syntax will not work.",
1872 } else if item
.is_enum() {
1874 "Non-exhaustive enums could have additional variants added in future. \
1875 Therefore, when matching against variants of non-exhaustive enums, an \
1876 extra wildcard arm must be added to account for any future variants.",
1878 } else if item
.is_variant() {
1880 "Non-exhaustive enum variants could have additional fields added in future. \
1881 Therefore, non-exhaustive enum variants cannot be constructed in external \
1882 crates and cannot be matched against.",
1886 "This type will require a wildcard arm in any match statements or constructors.",
1890 w
.write_str("</div></details>");
1894 fn document_type_layout(w
: &mut Buffer
, cx
: &Context
<'_
>, ty_def_id
: DefId
) {
1895 fn write_size_of_layout(w
: &mut Buffer
, layout
: &LayoutS
<VariantIdx
>, tag_size
: u64) {
1896 if layout
.abi
.is_unsized() {
1897 write
!(w
, "(unsized)");
1899 let bytes
= layout
.size
.bytes() - tag_size
;
1900 write
!(w
, "{size} byte{pl}", size
= bytes
, pl
= if bytes
== 1 { "" }
else { "s" }
,);
1904 if !cx
.shared
.show_type_layout
{
1910 "<h2 id=\"layout\" class=\"small-section-header\"> \
1911 Layout<a href=\"#layout\" class=\"anchor\">§</a></h2>"
1913 writeln
!(w
, "<div class=\"docblock\">");
1916 let param_env
= tcx
.param_env(ty_def_id
);
1917 let ty
= tcx
.type_of(ty_def_id
);
1918 match tcx
.layout_of(param_env
.and(ty
)) {
1922 "<div class=\"warning\"><p><strong>Note:</strong> Most layout information is \
1923 <strong>completely unstable</strong> and may even differ between compilations. \
1924 The only exception is types with certain <code>repr(...)</code> attributes. \
1925 Please see the Rust Reference’s \
1926 <a href=\"https://doc.rust-lang.org/reference/type-layout.html\">“Type Layout”</a> \
1927 chapter for details on type layout guarantees.</p></div>"
1929 w
.write_str("<p><strong>Size:</strong> ");
1930 write_size_of_layout(w
, &ty_layout
.layout
.0, 0);
1931 writeln
!(w
, "</p>");
1932 if let Variants
::Multiple { variants, tag, tag_encoding, .. }
=
1933 &ty_layout
.layout
.variants()
1935 if !variants
.is_empty() {
1937 "<p><strong>Size for each variant:</strong></p>\
1941 let Adt(adt
, _
) = ty_layout
.ty
.kind() else {
1942 span_bug
!(tcx
.def_span(ty_def_id
), "not an adt")
1945 let tag_size
= if let TagEncoding
::Niche { .. }
= tag_encoding
{
1947 } else if let Primitive
::Int(i
, _
) = tag
.primitive() {
1950 span_bug
!(tcx
.def_span(ty_def_id
), "tag is neither niche nor int")
1953 for (index
, layout
) in variants
.iter_enumerated() {
1954 let name
= adt
.variant(index
).name
;
1955 write
!(w
, "<li><code>{name}</code>: ", name
= name
);
1956 write_size_of_layout(w
, layout
, tag_size
);
1957 writeln
!(w
, "</li>");
1959 w
.write_str("</ul>");
1963 // This kind of layout error can occur with valid code, e.g. if you try to
1964 // get the layout of a generic type such as `Vec<T>`.
1965 Err(LayoutError
::Unknown(_
)) => {
1968 "<p><strong>Note:</strong> Unable to compute type layout, \
1969 possibly due to this type having generic parameters. \
1970 Layout can only be computed for concrete, fully-instantiated types.</p>"
1973 // This kind of error probably can't happen with valid code, but we don't
1974 // want to panic and prevent the docs from building, so we just let the
1975 // user know that we couldn't compute the layout.
1976 Err(LayoutError
::SizeOverflow(_
)) => {
1979 "<p><strong>Note:</strong> Encountered an error during type layout; \
1980 the type was too big.</p>"
1983 Err(LayoutError
::NormalizationFailure(_
, _
)) => {
1986 "<p><strong>Note:</strong> Encountered an error during type layout; \
1987 the type failed to be normalized.</p>"
1992 writeln
!(w
, "</div>");
1995 fn pluralize(count
: usize) -> &'
static str {
1996 if count
> 1 { "s" }
else { "" }