1use std::borrow::Cow;
2use std::fmt;
3use std::path::PathBuf;
4
5pub use ReprAttr::*;
6use rustc_abi::Align;
7pub use rustc_ast::attr::data_structures::*;
8pub use rustc_ast::attr::version::RustcVersion;
9use rustc_ast::expand::autodiff_attrs::{DiffActivity, DiffMode};
10use rustc_ast::expand::typetree::TypeTree;
11use rustc_ast::token::DocFragmentKind;
12use rustc_ast::{AttrStyle, Path, ast};
13use rustc_data_structures::fx::FxIndexMap;
14use rustc_error_messages::{DiagArgValue, IntoDiagArg};
15use rustc_lint_defs::ToolOptions;
16use rustc_macros::{
17 Decodable, Decodable_NoContext, Encodable, Encodable_NoContext, PrintAttribute, StableHash,
18};
19use rustc_span::def_id::DefId;
20use rustc_span::hygiene::Transparency;
21use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
22use rustc_structures::{CollapseMacroDebuginfo, CrateType, Limit, NativeLibKind, SanitizerSet};
23use thin_vec::ThinVec;
24
25pub use crate::canonical_symbols::{CanonicalSymbol, CanonicalSymbols};
26use crate::diagnostic::*;
27use crate::lang_items::LangItem;
28use crate::lint::LintCheck;
29use crate::pretty_printing::PrintAttribute;
30use crate::stability::{DefaultBodyStability, PartialConstStability, Stability};
31
32#[derive(#[automatically_derived]impl ::core::marker::Copy for EiiImplResolution { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for EiiImplResolution {
}
#[automatically_derived]impl ::core::clone::Clone for EiiImplResolution {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<DefId>;
let _: ::core::clone::AssertParamIsClone<ErrorGuaranteed>;
*self
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for EiiImplResolution {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Macro(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Macro",
&__self_0),
Self::Known(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Known",
&__self_0),
Self::Error(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Error",
&__self_0),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
EiiImplResolution {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
EiiImplResolution::Macro(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
EiiImplResolution::Known(ref __binding_0) =>
1u8.stable_hash(__hcx, __hasher),
EiiImplResolution::Error(ref __binding_0) =>
2u8.stable_hash(__hcx, __hasher),
}
match *self {
EiiImplResolution::Macro(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
EiiImplResolution::Known(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
EiiImplResolution::Error(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for EiiImplResolution {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
EiiImplResolution::Macro(ref __binding_0) => { 0usize }
EiiImplResolution::Known(ref __binding_0) => { 1usize }
EiiImplResolution::Error(ref __binding_0) => { 2usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
EiiImplResolution::Macro(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
EiiImplResolution::Known(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
EiiImplResolution::Error(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for EiiImplResolution {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
EiiImplResolution::Macro(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => {
EiiImplResolution::Known(::rustc_serialize::Decodable::decode(__decoder))
}
2usize => {
EiiImplResolution::Error(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `EiiImplResolution`, expected 0..3, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for EiiImplResolution {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Macro(f0) => {
__p.word("Macro");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Known(f0) => {
__p.word("Known");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Error(f0) => {
__p.word("Error");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute)]
33pub enum EiiImplResolution {
34 Macro(DefId),
38 Known(DefId),
41 Error(ErrorGuaranteed),
43}
44
45#[derive(#[automatically_derived]impl ::core::marker::Copy for EiiImpl { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for EiiImpl {
}
#[automatically_derived]impl ::core::clone::Clone for EiiImpl {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<EiiImplResolution>;
let _: ::core::clone::AssertParamIsClone<Option<Span>>;
let _: ::core::clone::AssertParamIsClone<Span>;
let _: ::core::clone::AssertParamIsClone<bool>;
*self
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for EiiImpl {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field5_finish(f,
"EiiImpl resolution impl_unsafe_span span inner_span is_default",
&self.resolution, &self.impl_unsafe_span, &self.span,
&self.inner_span, &&self.is_default)
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for EiiImpl {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
EiiImpl {
resolution: ref __binding_0,
impl_unsafe_span: ref __binding_1,
span: ref __binding_2,
inner_span: ref __binding_3,
is_default: ref __binding_4 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
{ __binding_4.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for EiiImpl {
fn encode(&self, __encoder: &mut __E) {
let EiiImpl {
resolution: ref __binding_0,
impl_unsafe_span: ref __binding_1,
span: ref __binding_2,
inner_span: ref __binding_3,
is_default: ref __binding_4 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_4,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for EiiImpl {
fn decode(__decoder: &mut __D) -> Self {
EiiImpl {
resolution: ::rustc_serialize::Decodable::decode(__decoder),
impl_unsafe_span: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
inner_span: ::rustc_serialize::Decodable::decode(__decoder),
is_default: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for EiiImpl {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self {
resolution, impl_unsafe_span, span, inner_span, is_default
} = self;
__p.word("EiiImpl");
if true && !resolution.should_render() &&
!impl_unsafe_span.should_render() && !span.should_render()
&& !inner_span.should_render() &&
!is_default.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if resolution.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("resolution");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
resolution.print_attribute(__p);
if impl_unsafe_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("impl_unsafe_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
impl_unsafe_span.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if inner_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("inner_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
inner_span.print_attribute(__p);
if is_default.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("is_default");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
is_default.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
46pub struct EiiImpl {
47 pub resolution: EiiImplResolution,
48 pub impl_unsafe_span: Option<Span>,
49 pub span: Span,
50 pub inner_span: Span,
51 pub is_default: bool,
52}
53
54#[derive(#[automatically_derived]impl ::core::marker::Copy for EiiDecl { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for EiiDecl {
}
#[automatically_derived]impl ::core::clone::Clone for EiiDecl {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<DefId>;
let _: ::core::clone::AssertParamIsClone<bool>;
let _: ::core::clone::AssertParamIsClone<Ident>;
*self
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for EiiDecl {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(f,
"EiiDecl foreign_item impl_unsafe name", &self.foreign_item,
&self.impl_unsafe, &&self.name)
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for EiiDecl {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
EiiDecl {
foreign_item: ref __binding_0,
impl_unsafe: ref __binding_1,
name: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for EiiDecl {
fn encode(&self, __encoder: &mut __E) {
let EiiDecl {
foreign_item: ref __binding_0,
impl_unsafe: ref __binding_1,
name: ref __binding_2 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for EiiDecl {
fn decode(__decoder: &mut __D) -> Self {
EiiDecl {
foreign_item: ::rustc_serialize::Decodable::decode(__decoder),
impl_unsafe: ::rustc_serialize::Decodable::decode(__decoder),
name: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for EiiDecl {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { foreign_item, impl_unsafe, name } = self;
__p.word("EiiDecl");
if true && !foreign_item.should_render() &&
!impl_unsafe.should_render() && !name.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if foreign_item.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("foreign_item");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
foreign_item.print_attribute(__p);
if impl_unsafe.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("impl_unsafe");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
impl_unsafe.print_attribute(__p);
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
55pub struct EiiDecl {
56 pub foreign_item: DefId,
57 pub impl_unsafe: bool,
59 pub name: Ident,
60}
61
62#[derive(#[automatically_derived]impl ::core::marker::Copy for CguKind { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for CguKind {
}
#[automatically_derived]impl ::core::clone::Clone for CguKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for CguKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for CguKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for CguKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
CguKind::No => { 0usize }
CguKind::PreDashLto => { 1usize }
CguKind::PostDashLto => { 2usize }
CguKind::Any => { 3usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for CguKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { CguKind::No }
1usize => { CguKind::PreDashLto }
2usize => { CguKind::PostDashLto }
3usize => { CguKind::Any }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `CguKind`, expected 0..4, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for CguKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
CguKind::No => "No",
CguKind::PreDashLto => "PreDashLto",
CguKind::PostDashLto => "PostDashLto",
CguKind::Any => "Any",
})
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for CguKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
CguKind::No => 0u8.stable_hash(__hcx, __hasher),
CguKind::PreDashLto => 1u8.stable_hash(__hcx, __hasher),
CguKind::PostDashLto => 2u8.stable_hash(__hcx, __hasher),
CguKind::Any => 3u8.stable_hash(__hcx, __hasher),
}
match *self {
CguKind::No => {}
CguKind::PreDashLto => {}
CguKind::PostDashLto => {}
CguKind::Any => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for CguKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::No => { __p.word("No") }
Self::PreDashLto => { __p.word("PreDashLto") }
Self::PostDashLto => { __p.word("PostDashLto") }
Self::Any => { __p.word("Any") }
}
}
}
};PrintAttribute)]
63pub enum CguKind {
64 No,
65 PreDashLto,
66 PostDashLto,
67 Any,
68}
69
70#[derive(#[automatically_derived]impl ::core::marker::Copy for CguFields { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for CguFields {
}
#[automatically_derived]impl ::core::clone::Clone for CguFields {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<Symbol>;
let _: ::core::clone::AssertParamIsClone<CguKind>;
*self
}
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for CguFields
{
}
#[automatically_derived]impl ::core::cmp::PartialEq for CguFields {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::PartitionReused { cfg: __self_0, module: __self_1 },
Self::PartitionReused { cfg: __arg1_0, module: __arg1_1 })
=> __self_0 == __arg1_0 && __self_1 == __arg1_1,
(Self::PartitionCodegened { cfg: __self_0, module: __self_1 },
Self::PartitionCodegened { cfg: __arg1_0, module: __arg1_1
}) => __self_0 == __arg1_0 && __self_1 == __arg1_1,
(Self::ExpectedCguReuse {
cfg: __self_0, module: __self_1, kind: __self_2 },
Self::ExpectedCguReuse {
cfg: __arg1_0, module: __arg1_1, kind: __arg1_2 }) =>
__self_0 == __arg1_0 && __self_1 == __arg1_1 &&
__self_2 == __arg1_2,
_ => unsafe { ::core::intrinsics::unreachable() }
}
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for CguFields {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
CguFields::PartitionReused {
cfg: ref __binding_0, module: ref __binding_1 } => {
0usize
}
CguFields::PartitionCodegened {
cfg: ref __binding_0, module: ref __binding_1 } => {
1usize
}
CguFields::ExpectedCguReuse {
cfg: ref __binding_0,
module: ref __binding_1,
kind: ref __binding_2 } => {
2usize
}
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
CguFields::PartitionReused {
cfg: ref __binding_0, module: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
CguFields::PartitionCodegened {
cfg: ref __binding_0, module: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
CguFields::ExpectedCguReuse {
cfg: ref __binding_0,
module: ref __binding_1,
kind: ref __binding_2 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for CguFields {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
CguFields::PartitionReused {
cfg: ::rustc_serialize::Decodable::decode(__decoder),
module: ::rustc_serialize::Decodable::decode(__decoder),
}
}
1usize => {
CguFields::PartitionCodegened {
cfg: ::rustc_serialize::Decodable::decode(__decoder),
module: ::rustc_serialize::Decodable::decode(__decoder),
}
}
2usize => {
CguFields::ExpectedCguReuse {
cfg: ::rustc_serialize::Decodable::decode(__decoder),
module: ::rustc_serialize::Decodable::decode(__decoder),
kind: ::rustc_serialize::Decodable::decode(__decoder),
}
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `CguFields`, expected 0..3, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for CguFields {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::PartitionReused { cfg: __self_0, module: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"PartitionReused cfg module", __self_0, &__self_1),
Self::PartitionCodegened { cfg: __self_0, module: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"PartitionCodegened cfg module", __self_0, &__self_1),
Self::ExpectedCguReuse {
cfg: __self_0, module: __self_1, kind: __self_2 } =>
::core::fmt::Formatter::debug_struct_field3_finish(f,
"ExpectedCguReuse cfg module kind", __self_0, __self_1,
&__self_2),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for CguFields {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
CguFields::PartitionReused {
cfg: ref __binding_0, module: ref __binding_1 } =>
0u8.stable_hash(__hcx, __hasher),
CguFields::PartitionCodegened {
cfg: ref __binding_0, module: ref __binding_1 } =>
1u8.stable_hash(__hcx, __hasher),
CguFields::ExpectedCguReuse {
cfg: ref __binding_0,
module: ref __binding_1,
kind: ref __binding_2 } => 2u8.stable_hash(__hcx, __hasher),
}
match *self {
CguFields::PartitionReused {
cfg: ref __binding_0, module: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
CguFields::PartitionCodegened {
cfg: ref __binding_0, module: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
CguFields::ExpectedCguReuse {
cfg: ref __binding_0,
module: ref __binding_1,
kind: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for CguFields {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::PartitionReused { cfg, module } => {
__p.word("PartitionReused");
if true && !cfg.should_render() && !module.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
cfg.print_attribute(__p);
if module.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("module");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
module.print_attribute(__p);
__p.word("}");
}
Self::PartitionCodegened { cfg, module } => {
__p.word("PartitionCodegened");
if true && !cfg.should_render() && !module.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
cfg.print_attribute(__p);
if module.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("module");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
module.print_attribute(__p);
__p.word("}");
}
Self::ExpectedCguReuse { cfg, module, kind } => {
__p.word("ExpectedCguReuse");
if true && !cfg.should_render() && !module.should_render()
&& !kind.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
cfg.print_attribute(__p);
if module.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("module");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
module.print_attribute(__p);
if kind.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("kind");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
kind.print_attribute(__p);
__p.word("}");
}
}
}
}
};PrintAttribute)]
71pub enum CguFields {
72 PartitionReused { cfg: Symbol, module: Symbol },
73 PartitionCodegened { cfg: Symbol, module: Symbol },
74 ExpectedCguReuse { cfg: Symbol, module: Symbol, kind: CguKind },
75}
76
77#[derive(#[automatically_derived]impl ::core::marker::Copy for InlineAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for InlineAttr {
}
#[automatically_derived]impl ::core::clone::Clone for InlineAttr {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<Span>;
let _: ::core::clone::AssertParamIsClone<Option<Symbol>>;
*self
}
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
InlineAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for InlineAttr {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Force { attr_span: __self_0, reason: __self_1 },
Self::Force { attr_span: __arg1_0, reason: __arg1_1 }) =>
__self_0 == __arg1_0 && __self_1 == __arg1_1,
_ => true,
}
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for InlineAttr {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
InlineAttr::None => { 0usize }
InlineAttr::Hint => { 1usize }
InlineAttr::Always => { 2usize }
InlineAttr::Never => { 3usize }
InlineAttr::Force {
attr_span: ref __binding_0, reason: ref __binding_1 } => {
4usize
}
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
InlineAttr::None => {}
InlineAttr::Hint => {}
InlineAttr::Always => {}
InlineAttr::Never => {}
InlineAttr::Force {
attr_span: ref __binding_0, reason: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for InlineAttr {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { InlineAttr::None }
1usize => { InlineAttr::Hint }
2usize => { InlineAttr::Always }
3usize => { InlineAttr::Never }
4usize => {
InlineAttr::Force {
attr_span: ::rustc_serialize::Decodable::decode(__decoder),
reason: ::rustc_serialize::Decodable::decode(__decoder),
}
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `InlineAttr`, expected 0..5, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for InlineAttr {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::None => ::core::fmt::Formatter::write_str(f, "None"),
Self::Hint => ::core::fmt::Formatter::write_str(f, "Hint"),
Self::Always => ::core::fmt::Formatter::write_str(f, "Always"),
Self::Never => ::core::fmt::Formatter::write_str(f, "Never"),
Self::Force { attr_span: __self_0, reason: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Force attr_span reason", __self_0, &__self_1),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for InlineAttr {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
InlineAttr::None => 0u8.stable_hash(__hcx, __hasher),
InlineAttr::Hint => 1u8.stable_hash(__hcx, __hasher),
InlineAttr::Always => 2u8.stable_hash(__hcx, __hasher),
InlineAttr::Never => 3u8.stable_hash(__hcx, __hasher),
InlineAttr::Force {
attr_span: ref __binding_0, reason: ref __binding_1 } =>
4u8.stable_hash(__hcx, __hasher),
}
match *self {
InlineAttr::None => {}
InlineAttr::Hint => {}
InlineAttr::Always => {}
InlineAttr::Never => {}
InlineAttr::Force {
attr_span: ref __binding_0, reason: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for InlineAttr {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::None => { __p.word("None") }
Self::Hint => { __p.word("Hint") }
Self::Always => { __p.word("Always") }
Self::Never => { __p.word("Never") }
Self::Force { attr_span, reason } => {
__p.word("Force");
if true && !attr_span.should_render() &&
!reason.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if attr_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_span.print_attribute(__p);
if reason.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reason");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reason.print_attribute(__p);
__p.word("}");
}
}
}
}
};PrintAttribute)]
78pub enum InlineAttr {
79 None,
80 Hint,
81 Always,
82 Never,
83 Force {
87 attr_span: Span,
88 reason: Option<Symbol>,
89 },
90}
91
92impl InlineAttr {
93 pub fn always(&self) -> bool {
94 match self {
95 InlineAttr::Always | InlineAttr::Force { .. } => true,
96 InlineAttr::None | InlineAttr::Hint | InlineAttr::Never => false,
97 }
98 }
99}
100
101#[derive(#[automatically_derived]impl ::core::marker::Copy for UnrollAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for UnrollAttr {
}
#[automatically_derived]impl ::core::clone::Clone for UnrollAttr {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<u32>;
*self
}
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
UnrollAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for UnrollAttr {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Count(__self_0), Self::Count(__arg1_0)) =>
__self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for UnrollAttr {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
UnrollAttr::Hint => { 0usize }
UnrollAttr::Full => { 1usize }
UnrollAttr::Never => { 2usize }
UnrollAttr::Count(ref __binding_0) => { 3usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
UnrollAttr::Hint => {}
UnrollAttr::Full => {}
UnrollAttr::Never => {}
UnrollAttr::Count(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for UnrollAttr {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { UnrollAttr::Hint }
1usize => { UnrollAttr::Full }
2usize => { UnrollAttr::Never }
3usize => {
UnrollAttr::Count(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `UnrollAttr`, expected 0..4, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for UnrollAttr {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Hint => ::core::fmt::Formatter::write_str(f, "Hint"),
Self::Full => ::core::fmt::Formatter::write_str(f, "Full"),
Self::Never => ::core::fmt::Formatter::write_str(f, "Never"),
Self::Count(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Count",
&__self_0),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for UnrollAttr {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
UnrollAttr::Hint => 0u8.stable_hash(__hcx, __hasher),
UnrollAttr::Full => 1u8.stable_hash(__hcx, __hasher),
UnrollAttr::Never => 2u8.stable_hash(__hcx, __hasher),
UnrollAttr::Count(ref __binding_0) =>
3u8.stable_hash(__hcx, __hasher),
}
match *self {
UnrollAttr::Hint => {}
UnrollAttr::Full => {}
UnrollAttr::Never => {}
UnrollAttr::Count(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for UnrollAttr {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Hint => { __p.word("Hint") }
Self::Full => { __p.word("Full") }
Self::Never => { __p.word("Never") }
Self::Count(f0) => {
__p.word("Count");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute)]
102pub enum UnrollAttr {
103 Hint,
104 Full,
105 Never,
106 Count(u32),
107}
108
109#[derive(#[automatically_derived]impl ::core::marker::Copy for InstructionSetAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for InstructionSetAttr {
}
#[automatically_derived]impl ::core::clone::Clone for InstructionSetAttr {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for InstructionSetAttr {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
InstructionSetAttr::ArmA32 => { 0usize }
InstructionSetAttr::ArmT32 => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for InstructionSetAttr {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { InstructionSetAttr::ArmA32 }
1usize => { InstructionSetAttr::ArmT32 }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `InstructionSetAttr`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for InstructionSetAttr {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
InstructionSetAttr::ArmA32 => "ArmA32",
InstructionSetAttr::ArmT32 => "ArmT32",
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
InstructionSetAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for InstructionSetAttr {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for InstructionSetAttr { }Eq, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
InstructionSetAttr {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
InstructionSetAttr::ArmA32 =>
0u8.stable_hash(__hcx, __hasher),
InstructionSetAttr::ArmT32 =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
InstructionSetAttr::ArmA32 => {}
InstructionSetAttr::ArmT32 => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for InstructionSetAttr {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::ArmA32 => { __p.word("ArmA32") }
Self::ArmT32 => { __p.word("ArmT32") }
}
}
}
};PrintAttribute)]
110pub enum InstructionSetAttr {
111 ArmA32,
112 ArmT32,
113}
114
115#[derive(#[automatically_derived]impl ::core::marker::Copy for InstrumentFnAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for InstrumentFnAttr {
}
#[automatically_derived]impl ::core::clone::Clone for InstrumentFnAttr {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for InstrumentFnAttr {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
InstrumentFnAttr::On => "On",
InstrumentFnAttr::Off => "Off",
})
}
}Debug)]
116#[derive(const _: () =
{
impl<__E: ::rustc_serialize::Encoder>
::rustc_serialize::Encodable<__E> for InstrumentFnAttr {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
InstrumentFnAttr::On => { 0usize }
InstrumentFnAttr::Off => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable_NoContext, const _: () =
{
impl<__D: ::rustc_serialize::Decoder>
::rustc_serialize::Decodable<__D> for InstrumentFnAttr {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { InstrumentFnAttr::On }
1usize => { InstrumentFnAttr::Off }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `InstrumentFnAttr`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable_NoContext, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
InstrumentFnAttr {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
InstrumentFnAttr::On => 0u8.stable_hash(__hcx, __hasher),
InstrumentFnAttr::Off => 1u8.stable_hash(__hcx, __hasher),
}
match *self {
InstrumentFnAttr::On => {}
InstrumentFnAttr::Off => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for InstrumentFnAttr {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::On => { __p.word("On") }
Self::Off => { __p.word("Off") }
}
}
}
};PrintAttribute)]
117pub enum InstrumentFnAttr {
118 On,
120 Off,
122}
123
124#[derive(#[automatically_derived]impl ::core::marker::Copy for OptimizeAttr { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for OptimizeAttr {
}
#[automatically_derived]impl ::core::clone::Clone for OptimizeAttr {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for OptimizeAttr {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
OptimizeAttr::Default => "Default",
OptimizeAttr::DoNotOptimize => "DoNotOptimize",
OptimizeAttr::Speed => "Speed",
OptimizeAttr::Size => "Size",
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
OptimizeAttr {
}
#[automatically_derived]impl ::core::cmp::PartialEq for OptimizeAttr {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for OptimizeAttr { }Eq, #[automatically_derived]impl ::core::default::Default for OptimizeAttr {
#[inline]
fn default() -> Self { Self::Default }
}Default, const _: () =
{
#[allow(unused)]
impl PrintAttribute for OptimizeAttr {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Default => { __p.word("Default") }
Self::DoNotOptimize => { __p.word("DoNotOptimize") }
Self::Speed => { __p.word("Speed") }
Self::Size => { __p.word("Size") }
}
}
}
};PrintAttribute)]
125#[derive(const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for OptimizeAttr {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
OptimizeAttr::Default => { 0usize }
OptimizeAttr::DoNotOptimize => { 1usize }
OptimizeAttr::Speed => { 2usize }
OptimizeAttr::Size => { 3usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for OptimizeAttr {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { OptimizeAttr::Default }
1usize => { OptimizeAttr::DoNotOptimize }
2usize => { OptimizeAttr::Speed }
3usize => { OptimizeAttr::Size }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `OptimizeAttr`, expected 0..4, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for OptimizeAttr
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
OptimizeAttr::Default => 0u8.stable_hash(__hcx, __hasher),
OptimizeAttr::DoNotOptimize =>
1u8.stable_hash(__hcx, __hasher),
OptimizeAttr::Speed => 2u8.stable_hash(__hcx, __hasher),
OptimizeAttr::Size => 3u8.stable_hash(__hcx, __hasher),
}
match *self {
OptimizeAttr::Default => {}
OptimizeAttr::DoNotOptimize => {}
OptimizeAttr::Speed => {}
OptimizeAttr::Size => {}
}
}
}
};StableHash)]
126pub enum OptimizeAttr {
127 #[default]
129 Default,
130 DoNotOptimize,
132 Speed,
134 Size,
136}
137
138impl OptimizeAttr {
139 pub fn do_not_optimize(&self) -> bool {
140 #[allow(non_exhaustive_omitted_patterns)] match self {
Self::DoNotOptimize => true,
_ => false,
}matches!(self, Self::DoNotOptimize)
141 }
142}
143
144#[derive(
145 #[automatically_derived]impl ::core::marker::StructuralPartialEq for ReprAttr
{
}
#[automatically_derived]impl ::core::cmp::PartialEq for ReprAttr {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::ReprInt(__self_0), Self::ReprInt(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::ReprPacked(__self_0), Self::ReprPacked(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::ReprAlign(__self_0), Self::ReprAlign(__arg1_0)) =>
__self_0 == __arg1_0,
_ => true,
}
}
}PartialEq,
146 #[automatically_derived]impl ::core::cmp::Eq for ReprAttr {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<IntType>;
let _: ::core::cmp::AssertParamIsEq<Align>;
}
}Eq,
147 #[automatically_derived]impl ::core::fmt::Debug for ReprAttr {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::ReprInt(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ReprInt", &__self_0),
Self::ReprRust =>
::core::fmt::Formatter::write_str(f, "ReprRust"),
Self::ReprC => ::core::fmt::Formatter::write_str(f, "ReprC"),
Self::ReprPacked(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ReprPacked", &__self_0),
Self::ReprSimd =>
::core::fmt::Formatter::write_str(f, "ReprSimd"),
Self::ReprTransparent =>
::core::fmt::Formatter::write_str(f, "ReprTransparent"),
Self::ReprAlign(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ReprAlign", &__self_0),
}
}
}Debug,
148 #[automatically_derived]impl ::core::cmp::PartialOrd for ReprAttr {
#[inline]
fn partial_cmp(&self, other: &Self)
-> ::core::option::Option<::core::cmp::Ordering> {
::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
}
}PartialOrd,
149 #[automatically_derived]impl ::core::cmp::Ord for ReprAttr {
#[inline]
fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
match ::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
&::core::intrinsics::discriminant_value(other)) {
::core::cmp::Ordering::Equal =>
match (self, other) {
(Self::ReprInt(__self_0), Self::ReprInt(__arg1_0)) =>
::core::cmp::Ord::cmp(__self_0, __arg1_0),
(Self::ReprPacked(__self_0), Self::ReprPacked(__arg1_0)) =>
::core::cmp::Ord::cmp(__self_0, __arg1_0),
(Self::ReprAlign(__self_0), Self::ReprAlign(__arg1_0)) =>
::core::cmp::Ord::cmp(__self_0, __arg1_0),
_ => ::core::cmp::Ordering::Equal,
},
cmp => cmp,
}
}
}Ord,
150 const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for ReprAttr {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
ReprAttr::ReprInt(ref __binding_0) => { 0usize }
ReprAttr::ReprRust => { 1usize }
ReprAttr::ReprC => { 2usize }
ReprAttr::ReprPacked(ref __binding_0) => { 3usize }
ReprAttr::ReprSimd => { 4usize }
ReprAttr::ReprTransparent => { 5usize }
ReprAttr::ReprAlign(ref __binding_0) => { 6usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
ReprAttr::ReprInt(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
ReprAttr::ReprRust => {}
ReprAttr::ReprC => {}
ReprAttr::ReprPacked(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
ReprAttr::ReprSimd => {}
ReprAttr::ReprTransparent => {}
ReprAttr::ReprAlign(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable,
151 const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for ReprAttr {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
ReprAttr::ReprInt(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => { ReprAttr::ReprRust }
2usize => { ReprAttr::ReprC }
3usize => {
ReprAttr::ReprPacked(::rustc_serialize::Decodable::decode(__decoder))
}
4usize => { ReprAttr::ReprSimd }
5usize => { ReprAttr::ReprTransparent }
6usize => {
ReprAttr::ReprAlign(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `ReprAttr`, expected 0..7, actual {0}",
n));
}
}
}
}
};Decodable,
152 #[automatically_derived]impl ::core::marker::Copy for ReprAttr { }Copy,
153 #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for ReprAttr {
}
#[automatically_derived]impl ::core::clone::Clone for ReprAttr {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<IntType>;
let _: ::core::clone::AssertParamIsClone<Align>;
*self
}
}Clone,
154 const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for ReprAttr {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
ReprAttr::ReprInt(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
ReprAttr::ReprRust => 1u8.stable_hash(__hcx, __hasher),
ReprAttr::ReprC => 2u8.stable_hash(__hcx, __hasher),
ReprAttr::ReprPacked(ref __binding_0) =>
3u8.stable_hash(__hcx, __hasher),
ReprAttr::ReprSimd => 4u8.stable_hash(__hcx, __hasher),
ReprAttr::ReprTransparent =>
5u8.stable_hash(__hcx, __hasher),
ReprAttr::ReprAlign(ref __binding_0) =>
6u8.stable_hash(__hcx, __hasher),
}
match *self {
ReprAttr::ReprInt(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
ReprAttr::ReprRust => {}
ReprAttr::ReprC => {}
ReprAttr::ReprPacked(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
ReprAttr::ReprSimd => {}
ReprAttr::ReprTransparent => {}
ReprAttr::ReprAlign(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash,
155 const _: () =
{
#[allow(unused)]
impl PrintAttribute for ReprAttr {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::ReprInt(f0) => {
__p.word("ReprInt");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::ReprRust => { __p.word("ReprRust") }
Self::ReprC => { __p.word("ReprC") }
Self::ReprPacked(f0) => {
__p.word("ReprPacked");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::ReprSimd => { __p.word("ReprSimd") }
Self::ReprTransparent => { __p.word("ReprTransparent") }
Self::ReprAlign(f0) => {
__p.word("ReprAlign");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute
156)]
157pub enum ReprAttr {
158 ReprInt(IntType),
159 ReprRust,
160 ReprC,
161 ReprPacked(Align),
162 ReprSimd,
163 ReprTransparent,
164 ReprAlign(Align),
165}
166
167#[derive(#[automatically_derived]impl ::core::cmp::Eq for IntType {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<ast::IntTy>;
let _: ::core::cmp::AssertParamIsEq<ast::UintTy>;
}
}Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for IntType {
}
#[automatically_derived]impl ::core::cmp::PartialEq for IntType {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::SignedInt(__self_0), Self::SignedInt(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::UnsignedInt(__self_0), Self::UnsignedInt(__arg1_0)) =>
__self_0 == __arg1_0,
_ => unsafe { ::core::intrinsics::unreachable() }
}
}
}PartialEq, #[automatically_derived]impl ::core::fmt::Debug for IntType {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::SignedInt(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"SignedInt", &__self_0),
Self::UnsignedInt(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"UnsignedInt", &__self_0),
}
}
}Debug, #[automatically_derived]impl ::core::marker::Copy for IntType { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for IntType {
}
#[automatically_derived]impl ::core::clone::Clone for IntType {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<ast::IntTy>;
let _: ::core::clone::AssertParamIsClone<ast::UintTy>;
*self
}
}Clone, #[automatically_derived]impl ::core::cmp::PartialOrd for IntType {
#[inline]
fn partial_cmp(&self, other: &Self)
-> ::core::option::Option<::core::cmp::Ordering> {
::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
}
}PartialOrd, #[automatically_derived]impl ::core::cmp::Ord for IntType {
#[inline]
fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
match (self, other) {
(Self::SignedInt(__self_0), Self::SignedInt(__arg1_0)) =>
::core::cmp::Ord::cmp(__self_0, __arg1_0),
(Self::UnsignedInt(__self_0), Self::UnsignedInt(__arg1_0)) =>
::core::cmp::Ord::cmp(__self_0, __arg1_0),
_ =>
::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
&::core::intrinsics::discriminant_value(other)),
}
}
}Ord)]
168#[derive(const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for IntType {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
IntType::SignedInt(ref __binding_0) => { 0usize }
IntType::UnsignedInt(ref __binding_0) => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
IntType::SignedInt(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
IntType::UnsignedInt(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for IntType {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
IntType::SignedInt(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => {
IntType::UnsignedInt(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `IntType`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for IntType {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
IntType::SignedInt(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
IntType::UnsignedInt(ref __binding_0) =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
IntType::SignedInt(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
IntType::UnsignedInt(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for IntType {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::SignedInt(f0) => {
__p.word("SignedInt");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::UnsignedInt(f0) => {
__p.word("UnsignedInt");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute)]
169pub enum IntType {
170 SignedInt(ast::IntTy),
171 UnsignedInt(ast::UintTy),
172}
173
174#[derive(#[automatically_derived]impl ::core::marker::Copy for Deprecation { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Deprecation {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(f,
"Deprecation since note suggestion", &self.since, &self.note,
&&self.suggestion)
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for Deprecation {
fn encode(&self, __encoder: &mut __E) {
let Deprecation {
since: ref __binding_0,
note: ref __binding_1,
suggestion: ref __binding_2 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for Deprecation {
fn decode(__decoder: &mut __D) -> Self {
Deprecation {
since: ::rustc_serialize::Decodable::decode(__decoder),
note: ::rustc_serialize::Decodable::decode(__decoder),
suggestion: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for Deprecation {
}
#[automatically_derived]impl ::core::clone::Clone for Deprecation {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<DeprecatedSince>;
let _: ::core::clone::AssertParamIsClone<Option<Ident>>;
let _: ::core::clone::AssertParamIsClone<Option<Symbol>>;
*self
}
}Clone, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for Deprecation
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
Deprecation {
since: ref __binding_0,
note: ref __binding_1,
suggestion: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for Deprecation {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { since, note, suggestion } = self;
__p.word("Deprecation");
if true && !since.should_render() && !note.should_render() &&
!suggestion.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if since.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("since");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
since.print_attribute(__p);
if note.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("note");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
note.print_attribute(__p);
if suggestion.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("suggestion");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
suggestion.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
175pub struct Deprecation {
176 pub since: DeprecatedSince,
177 pub note: Option<Ident>,
179 pub suggestion: Option<Symbol>,
183}
184
185#[derive(#[automatically_derived]impl ::core::marker::Copy for DeprecatedSince { }Copy, #[automatically_derived]impl ::core::fmt::Debug for DeprecatedSince {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::RustcVersion(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcVersion", &__self_0),
Self::Future => ::core::fmt::Formatter::write_str(f, "Future"),
Self::NonStandard(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"NonStandard", &__self_0),
Self::Unspecified =>
::core::fmt::Formatter::write_str(f, "Unspecified"),
Self::Err => ::core::fmt::Formatter::write_str(f, "Err"),
}
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for DeprecatedSince {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
DeprecatedSince::RustcVersion(ref __binding_0) => { 0usize }
DeprecatedSince::Future => { 1usize }
DeprecatedSince::NonStandard(ref __binding_0) => { 2usize }
DeprecatedSince::Unspecified => { 3usize }
DeprecatedSince::Err => { 4usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
DeprecatedSince::RustcVersion(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
DeprecatedSince::Future => {}
DeprecatedSince::NonStandard(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
DeprecatedSince::Unspecified => {}
DeprecatedSince::Err => {}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DeprecatedSince {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
DeprecatedSince::RustcVersion(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => { DeprecatedSince::Future }
2usize => {
DeprecatedSince::NonStandard(::rustc_serialize::Decodable::decode(__decoder))
}
3usize => { DeprecatedSince::Unspecified }
4usize => { DeprecatedSince::Err }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DeprecatedSince`, expected 0..5, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for DeprecatedSince {
}
#[automatically_derived]impl ::core::clone::Clone for DeprecatedSince {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<RustcVersion>;
let _: ::core::clone::AssertParamIsClone<Symbol>;
*self
}
}Clone, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
DeprecatedSince {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DeprecatedSince::RustcVersion(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
DeprecatedSince::Future => 1u8.stable_hash(__hcx, __hasher),
DeprecatedSince::NonStandard(ref __binding_0) =>
2u8.stable_hash(__hcx, __hasher),
DeprecatedSince::Unspecified =>
3u8.stable_hash(__hcx, __hasher),
DeprecatedSince::Err => 4u8.stable_hash(__hcx, __hasher),
}
match *self {
DeprecatedSince::RustcVersion(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
DeprecatedSince::Future => {}
DeprecatedSince::NonStandard(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
DeprecatedSince::Unspecified => {}
DeprecatedSince::Err => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DeprecatedSince {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::RustcVersion(f0) => {
__p.word("RustcVersion");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Future => { __p.word("Future") }
Self::NonStandard(f0) => {
__p.word("NonStandard");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Unspecified => { __p.word("Unspecified") }
Self::Err => { __p.word("Err") }
}
}
}
};PrintAttribute)]
187pub enum DeprecatedSince {
188 RustcVersion(RustcVersion),
189 Future,
191 NonStandard(Symbol),
194 Unspecified,
196 Err,
199}
200
201#[derive(#[automatically_derived]impl ::core::marker::Copy for CoverageAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for CoverageAttrKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
CoverageAttrKind::On => "On",
CoverageAttrKind::Off => "Off",
})
}
}Debug, #[automatically_derived]impl ::core::cmp::Eq for CoverageAttrKind { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
CoverageAttrKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for CoverageAttrKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for CoverageAttrKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
CoverageAttrKind::On => { 0usize }
CoverageAttrKind::Off => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for CoverageAttrKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { CoverageAttrKind::On }
1usize => { CoverageAttrKind::Off }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `CoverageAttrKind`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for CoverageAttrKind {
}
#[automatically_derived]impl ::core::clone::Clone for CoverageAttrKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone)]
203#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
CoverageAttrKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
CoverageAttrKind::On => 0u8.stable_hash(__hcx, __hasher),
CoverageAttrKind::Off => 1u8.stable_hash(__hcx, __hasher),
}
match *self {
CoverageAttrKind::On => {}
CoverageAttrKind::Off => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for CoverageAttrKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::On => { __p.word("On") }
Self::Off => { __p.word("Off") }
}
}
}
};PrintAttribute)]
204pub enum CoverageAttrKind {
205 On,
206 Off,
207}
208
209#[derive(#[automatically_derived]impl ::core::marker::Copy for RustcAbiAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RustcAbiAttrKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
RustcAbiAttrKind::Debug => "Debug",
RustcAbiAttrKind::AssertEq => "AssertEq",
})
}
}Debug, #[automatically_derived]impl ::core::cmp::Eq for RustcAbiAttrKind { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RustcAbiAttrKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcAbiAttrKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcAbiAttrKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
RustcAbiAttrKind::Debug => { 0usize }
RustcAbiAttrKind::AssertEq => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcAbiAttrKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { RustcAbiAttrKind::Debug }
1usize => { RustcAbiAttrKind::AssertEq }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcAbiAttrKind`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for RustcAbiAttrKind {
}
#[automatically_derived]impl ::core::clone::Clone for RustcAbiAttrKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone)]
211#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcAbiAttrKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcAbiAttrKind::Debug => 0u8.stable_hash(__hcx, __hasher),
RustcAbiAttrKind::AssertEq =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
RustcAbiAttrKind::Debug => {}
RustcAbiAttrKind::AssertEq => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcAbiAttrKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Debug => { __p.word("Debug") }
Self::AssertEq => { __p.word("AssertEq") }
}
}
}
};PrintAttribute)]
212pub enum RustcAbiAttrKind {
213 Debug,
214 AssertEq,
215}
216
217impl Deprecation {
218 pub fn is_in_effect(&self) -> bool {
222 match self.since {
223 DeprecatedSince::RustcVersion(since) => since <= RustcVersion::CURRENT,
224 DeprecatedSince::Future => false,
225 DeprecatedSince::NonStandard(_) => true,
227 DeprecatedSince::Unspecified | DeprecatedSince::Err => true,
229 }
230 }
231
232 pub fn is_since_rustc_version(&self) -> bool {
233 #[allow(non_exhaustive_omitted_patterns)] match self.since {
DeprecatedSince::RustcVersion(_) => true,
_ => false,
}matches!(self.since, DeprecatedSince::RustcVersion(_))
234 }
235}
236
237#[derive(const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for UsedBy {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
UsedBy::Default => { 0usize }
UsedBy::Compiler => { 1usize }
UsedBy::Linker => { 2usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for UsedBy {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { UsedBy::Default }
1usize => { UsedBy::Compiler }
2usize => { UsedBy::Linker }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `UsedBy`, expected 0..3, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::marker::Copy for UsedBy { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for UsedBy {
}
#[automatically_derived]impl ::core::clone::Clone for UsedBy {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for UsedBy {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
UsedBy::Default => "Default",
UsedBy::Compiler => "Compiler",
UsedBy::Linker => "Linker",
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for UsedBy {
}
#[automatically_derived]impl ::core::cmp::PartialEq for UsedBy {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for UsedBy { }Eq, #[automatically_derived]impl ::core::hash::Hash for UsedBy {
#[inline]
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
state)
}
}Hash)]
242#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for UsedBy {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
UsedBy::Default => 0u8.stable_hash(__hcx, __hasher),
UsedBy::Compiler => 1u8.stable_hash(__hcx, __hasher),
UsedBy::Linker => 2u8.stable_hash(__hcx, __hasher),
}
match *self {
UsedBy::Default => {}
UsedBy::Compiler => {}
UsedBy::Linker => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for UsedBy {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Default => { __p.word("Default") }
Self::Compiler => { __p.word("Compiler") }
Self::Linker => { __p.word("Linker") }
}
}
}
};PrintAttribute)]
243pub enum UsedBy {
244 Default,
245 Compiler,
246 Linker,
247}
248
249#[derive(const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for MacroUseArgs {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
MacroUseArgs::UseAll => { 0usize }
MacroUseArgs::UseSpecific(ref __binding_0) => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
MacroUseArgs::UseAll => {}
MacroUseArgs::UseSpecific(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for MacroUseArgs {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { MacroUseArgs::UseAll }
1usize => {
MacroUseArgs::UseSpecific(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `MacroUseArgs`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::clone::Clone for MacroUseArgs {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
match self {
Self::UseAll => MacroUseArgs::UseAll,
Self::UseSpecific(__self_0) =>
MacroUseArgs::UseSpecific(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for MacroUseArgs {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::UseAll => ::core::fmt::Formatter::write_str(f, "UseAll"),
Self::UseSpecific(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"UseSpecific", &__self_0),
}
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
MacroUseArgs {
}
#[automatically_derived]impl ::core::cmp::PartialEq for MacroUseArgs {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::UseSpecific(__self_0), Self::UseSpecific(__arg1_0)) =>
__self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for MacroUseArgs {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<ThinVec<Ident>>;
}
}Eq, #[automatically_derived]impl ::core::hash::Hash for MacroUseArgs {
#[inline]
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
state);
match self {
Self::UseSpecific(__self_0) =>
::core::hash::Hash::hash(__self_0, state),
_ => {}
}
}
}Hash)]
250#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for MacroUseArgs
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
MacroUseArgs::UseAll => 0u8.stable_hash(__hcx, __hasher),
MacroUseArgs::UseSpecific(ref __binding_0) =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
MacroUseArgs::UseAll => {}
MacroUseArgs::UseSpecific(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for MacroUseArgs {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::UseAll => { __p.word("UseAll") }
Self::UseSpecific(f0) => {
__p.word("UseSpecific");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute)]
251pub enum MacroUseArgs {
252 UseAll,
253 UseSpecific(ThinVec<Ident>),
254}
255
256impl Default for MacroUseArgs {
257 fn default() -> Self {
258 Self::UseSpecific(ThinVec::new())
259 }
260}
261
262#[derive(#[automatically_derived]impl<ScopeId: ::core::fmt::Debug> ::core::fmt::Debug
for StrippedCfgItem<ScopeId> {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(f,
"StrippedCfgItem parent_scope ident cfg", &self.parent_scope,
&self.ident, &&self.cfg)
}
}Debug, #[automatically_derived]impl<ScopeId: ::core::clone::Clone>
::core::clone::Clone for StrippedCfgItem<ScopeId> {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
StrippedCfgItem {
parent_scope: ::core::clone::Clone::clone(&self.parent_scope),
ident: ::core::clone::Clone::clone(&self.ident),
cfg: ::core::clone::Clone::clone(&self.cfg),
}
}
}Clone, const _: () =
{
impl<ScopeId, __E: ::rustc_span::SpanEncoder>
::rustc_serialize::Encodable<__E> for StrippedCfgItem<ScopeId>
where ScopeId: ::rustc_serialize::Encodable<__E> {
fn encode(&self, __encoder: &mut __E) {
let StrippedCfgItem {
parent_scope: ref __binding_0,
ident: ref __binding_1,
cfg: ref __binding_2 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
}
};Encodable, const _: () =
{
impl<ScopeId, __D: ::rustc_span::SpanDecoder>
::rustc_serialize::Decodable<__D> for StrippedCfgItem<ScopeId>
where ScopeId: ::rustc_serialize::Decodable<__D> {
fn decode(__decoder: &mut __D) -> Self {
StrippedCfgItem {
parent_scope: ::rustc_serialize::Decodable::decode(__decoder),
ident: ::rustc_serialize::Decodable::decode(__decoder),
cfg: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
impl<ScopeId> ::rustc_data_structures::stable_hash::StableHash for
StrippedCfgItem<ScopeId> where
ScopeId: ::rustc_data_structures::stable_hash::StableHash {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
StrippedCfgItem {
parent_scope: ref __binding_0,
ident: ref __binding_1,
cfg: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash)]
263pub struct StrippedCfgItem<ScopeId = DefId> {
264 pub parent_scope: ScopeId,
265 pub ident: Ident,
266 pub cfg: (CfgEntry, Span),
267}
268
269impl<ScopeId> StrippedCfgItem<ScopeId> {
270 pub fn map_scope_id<New>(self, f: impl FnOnce(ScopeId) -> New) -> StrippedCfgItem<New> {
271 StrippedCfgItem { parent_scope: f(self.parent_scope), ident: self.ident, cfg: self.cfg }
272 }
273}
274
275#[derive(const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for Linkage {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
Linkage::AvailableExternally => { 0usize }
Linkage::ExternalWeak => { 1usize }
Linkage::External => { 2usize }
Linkage::Internal => { 3usize }
Linkage::LinkOnceAny => { 4usize }
Linkage::LinkOnceODR => { 5usize }
Linkage::WeakAny => { 6usize }
Linkage::WeakODR => { 7usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for Linkage {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { Linkage::AvailableExternally }
1usize => { Linkage::ExternalWeak }
2usize => { Linkage::External }
3usize => { Linkage::Internal }
4usize => { Linkage::LinkOnceAny }
5usize => { Linkage::LinkOnceODR }
6usize => { Linkage::WeakAny }
7usize => { Linkage::WeakODR }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `Linkage`, expected 0..8, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for Linkage {
}
#[automatically_derived]impl ::core::clone::Clone for Linkage {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for Linkage { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Linkage {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_c_like_enum_write_str(f,
"AvailableExternally ExternalWeak External Internal LinkOnceAny LinkOnceODR WeakAny WeakODR",
match self {
Linkage::AvailableExternally => 0usize,
Linkage::ExternalWeak => 20usize,
Linkage::External => 33usize,
Linkage::Internal => 42usize,
Linkage::LinkOnceAny => 51usize,
Linkage::LinkOnceODR => 63usize,
Linkage::WeakAny => 75usize,
Linkage::WeakODR => 83usize,
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for Linkage {
}
#[automatically_derived]impl ::core::cmp::PartialEq for Linkage {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for Linkage { }Eq, #[automatically_derived]impl ::core::hash::Hash for Linkage {
#[inline]
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
state)
}
}Hash)]
280#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for Linkage {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
Linkage::AvailableExternally =>
0u8.stable_hash(__hcx, __hasher),
Linkage::ExternalWeak => 1u8.stable_hash(__hcx, __hasher),
Linkage::External => 2u8.stable_hash(__hcx, __hasher),
Linkage::Internal => 3u8.stable_hash(__hcx, __hasher),
Linkage::LinkOnceAny => 4u8.stable_hash(__hcx, __hasher),
Linkage::LinkOnceODR => 5u8.stable_hash(__hcx, __hasher),
Linkage::WeakAny => 6u8.stable_hash(__hcx, __hasher),
Linkage::WeakODR => 7u8.stable_hash(__hcx, __hasher),
}
match *self {
Linkage::AvailableExternally => {}
Linkage::ExternalWeak => {}
Linkage::External => {}
Linkage::Internal => {}
Linkage::LinkOnceAny => {}
Linkage::LinkOnceODR => {}
Linkage::WeakAny => {}
Linkage::WeakODR => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for Linkage {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::AvailableExternally => {
__p.word("AvailableExternally")
}
Self::ExternalWeak => { __p.word("ExternalWeak") }
Self::External => { __p.word("External") }
Self::Internal => { __p.word("Internal") }
Self::LinkOnceAny => { __p.word("LinkOnceAny") }
Self::LinkOnceODR => { __p.word("LinkOnceODR") }
Self::WeakAny => { __p.word("WeakAny") }
Self::WeakODR => { __p.word("WeakODR") }
}
}
}
};PrintAttribute)]
281pub enum Linkage {
282 AvailableExternally,
283 ExternalWeak,
284 External,
285 Internal,
286 LinkOnceAny,
287 LinkOnceODR,
288 WeakAny,
289 WeakODR,
290}
291
292#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for MirDialect {
}
#[automatically_derived]impl ::core::clone::Clone for MirDialect {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for MirDialect { }Copy, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for MirDialect {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { MirDialect::Analysis }
1usize => { MirDialect::Built }
2usize => { MirDialect::Runtime }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `MirDialect`, expected 0..3, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for MirDialect {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
MirDialect::Analysis => "Analysis",
MirDialect::Built => "Built",
MirDialect::Runtime => "Runtime",
})
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for MirDialect {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
MirDialect::Analysis => { 0usize }
MirDialect::Built => { 1usize }
MirDialect::Runtime => { 2usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
MirDialect {
}
#[automatically_derived]impl ::core::cmp::PartialEq for MirDialect {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq)]
293#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for MirDialect {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
MirDialect::Analysis => 0u8.stable_hash(__hcx, __hasher),
MirDialect::Built => 1u8.stable_hash(__hcx, __hasher),
MirDialect::Runtime => 2u8.stable_hash(__hcx, __hasher),
}
match *self {
MirDialect::Analysis => {}
MirDialect::Built => {}
MirDialect::Runtime => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for MirDialect {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Analysis => { __p.word("Analysis") }
Self::Built => { __p.word("Built") }
Self::Runtime => { __p.word("Runtime") }
}
}
}
};PrintAttribute)]
294pub enum MirDialect {
295 Analysis,
296 Built,
297 Runtime,
298}
299
300impl IntoDiagArg for MirDialect {
301 fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
302 let arg = match self {
303 MirDialect::Analysis => "analysis",
304 MirDialect::Built => "built",
305 MirDialect::Runtime => "runtime",
306 };
307 DiagArgValue::Str(Cow::Borrowed(arg))
308 }
309}
310
311#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for MirPhase {
}
#[automatically_derived]impl ::core::clone::Clone for MirPhase {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for MirPhase { }Copy, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for MirPhase {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { MirPhase::Initial }
1usize => { MirPhase::PostCleanup }
2usize => { MirPhase::Optimized }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `MirPhase`, expected 0..3, actual {0}",
n));
}
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for MirPhase {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
MirPhase::Initial => "Initial",
MirPhase::PostCleanup => "PostCleanup",
MirPhase::Optimized => "Optimized",
})
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for MirPhase {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
MirPhase::Initial => { 0usize }
MirPhase::PostCleanup => { 1usize }
MirPhase::Optimized => { 2usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, #[automatically_derived]impl ::core::marker::StructuralPartialEq for MirPhase
{
}
#[automatically_derived]impl ::core::cmp::PartialEq for MirPhase {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq)]
312#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for MirPhase {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
MirPhase::Initial => 0u8.stable_hash(__hcx, __hasher),
MirPhase::PostCleanup => 1u8.stable_hash(__hcx, __hasher),
MirPhase::Optimized => 2u8.stable_hash(__hcx, __hasher),
}
match *self {
MirPhase::Initial => {}
MirPhase::PostCleanup => {}
MirPhase::Optimized => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for MirPhase {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Initial => { __p.word("Initial") }
Self::PostCleanup => { __p.word("PostCleanup") }
Self::Optimized => { __p.word("Optimized") }
}
}
}
};PrintAttribute)]
313pub enum MirPhase {
314 Initial,
315 PostCleanup,
316 Optimized,
317}
318
319impl IntoDiagArg for MirPhase {
320 fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
321 let arg = match self {
322 MirPhase::Initial => "initial",
323 MirPhase::PostCleanup => "post-cleanup",
324 MirPhase::Optimized => "optimized",
325 };
326 DiagArgValue::Str(Cow::Borrowed(arg))
327 }
328}
329
330#[derive(#[automatically_derived]impl ::core::marker::Copy for PeImportNameType { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for PeImportNameType {
}
#[automatically_derived]impl ::core::clone::Clone for PeImportNameType {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<u16>;
*self
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for PeImportNameType {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Ordinal(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Ordinal", &__self_0),
Self::Decorated =>
::core::fmt::Formatter::write_str(f, "Decorated"),
Self::NoPrefix =>
::core::fmt::Formatter::write_str(f, "NoPrefix"),
Self::Undecorated =>
::core::fmt::Formatter::write_str(f, "Undecorated"),
}
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for PeImportNameType {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
PeImportNameType::Ordinal(ref __binding_0) => { 0usize }
PeImportNameType::Decorated => { 1usize }
PeImportNameType::NoPrefix => { 2usize }
PeImportNameType::Undecorated => { 3usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
PeImportNameType::Ordinal(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
PeImportNameType::Decorated => {}
PeImportNameType::NoPrefix => {}
PeImportNameType::Undecorated => {}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for PeImportNameType {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
PeImportNameType::Ordinal(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => { PeImportNameType::Decorated }
2usize => { PeImportNameType::NoPrefix }
3usize => { PeImportNameType::Undecorated }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `PeImportNameType`, expected 0..4, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
PeImportNameType {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
PeImportNameType::Ordinal(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
PeImportNameType::Decorated =>
1u8.stable_hash(__hcx, __hasher),
PeImportNameType::NoPrefix =>
2u8.stable_hash(__hcx, __hasher),
PeImportNameType::Undecorated =>
3u8.stable_hash(__hcx, __hasher),
}
match *self {
PeImportNameType::Ordinal(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
PeImportNameType::Decorated => {}
PeImportNameType::NoPrefix => {}
PeImportNameType::Undecorated => {}
}
}
}
};StableHash, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
PeImportNameType {
}
#[automatically_derived]impl ::core::cmp::PartialEq for PeImportNameType {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Ordinal(__self_0), Self::Ordinal(__arg1_0)) =>
__self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for PeImportNameType {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<u16>;
}
}Eq, const _: () =
{
#[allow(unused)]
impl PrintAttribute for PeImportNameType {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Ordinal(f0) => {
__p.word("Ordinal");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Decorated => { __p.word("Decorated") }
Self::NoPrefix => { __p.word("NoPrefix") }
Self::Undecorated => { __p.word("Undecorated") }
}
}
}
};PrintAttribute)]
333pub enum PeImportNameType {
334 Ordinal(u16),
337 Decorated,
340 NoPrefix,
343 Undecorated,
347}
348
349#[derive(#[automatically_derived]impl ::core::fmt::Debug for LinkEntry {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
let names: &'static _ =
"LinkEntry span kind name cfg verbatim import_name_type";
let values: &[&dyn ::core::fmt::Debug] =
&[&self.span, &self.kind, &self.name, &self.cfg, &self.verbatim,
&&self.import_name_type];
::core::fmt::Formatter::debug_struct_fields_finish(f, names, values)
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for LinkEntry {
fn encode(&self, __encoder: &mut __E) {
let LinkEntry {
span: ref __binding_0,
kind: ref __binding_1,
name: ref __binding_2,
cfg: ref __binding_3,
verbatim: ref __binding_4,
import_name_type: ref __binding_5 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_4,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_5,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for LinkEntry {
fn decode(__decoder: &mut __D) -> Self {
LinkEntry {
span: ::rustc_serialize::Decodable::decode(__decoder),
kind: ::rustc_serialize::Decodable::decode(__decoder),
name: ::rustc_serialize::Decodable::decode(__decoder),
cfg: ::rustc_serialize::Decodable::decode(__decoder),
verbatim: ::rustc_serialize::Decodable::decode(__decoder),
import_name_type: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, #[automatically_derived]impl ::core::clone::Clone for LinkEntry {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
LinkEntry {
span: ::core::clone::Clone::clone(&self.span),
kind: ::core::clone::Clone::clone(&self.kind),
name: ::core::clone::Clone::clone(&self.name),
cfg: ::core::clone::Clone::clone(&self.cfg),
verbatim: ::core::clone::Clone::clone(&self.verbatim),
import_name_type: ::core::clone::Clone::clone(&self.import_name_type),
}
}
}Clone, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for LinkEntry {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
LinkEntry {
span: ref __binding_0,
kind: ref __binding_1,
name: ref __binding_2,
cfg: ref __binding_3,
verbatim: ref __binding_4,
import_name_type: ref __binding_5 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
{ __binding_4.stable_hash(__hcx, __hasher); }
{ __binding_5.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for LinkEntry {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { span, kind, name, cfg, verbatim, import_name_type
} = self;
__p.word("LinkEntry");
if true && !span.should_render() && !kind.should_render() &&
!name.should_render() && !cfg.should_render() &&
!verbatim.should_render() &&
!import_name_type.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if kind.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("kind");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
kind.print_attribute(__p);
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
if cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
cfg.print_attribute(__p);
if verbatim.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("verbatim");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
verbatim.print_attribute(__p);
if import_name_type.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("import_name_type");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
import_name_type.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
350pub struct LinkEntry {
351 pub span: Span,
352 pub kind: NativeLibKind,
353 pub name: Symbol,
354 pub cfg: Option<CfgEntry>,
355 pub verbatim: Option<bool>,
356 pub import_name_type: Option<(PeImportNameType, Span)>,
357}
358
359#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
DebuggerVisualizerType {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DebuggerVisualizerType::Natvis =>
0u8.stable_hash(__hcx, __hasher),
DebuggerVisualizerType::GdbPrettyPrinter =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
DebuggerVisualizerType::Natvis => {}
DebuggerVisualizerType::GdbPrettyPrinter => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DebuggerVisualizerType {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Natvis => { __p.word("Natvis") }
Self::GdbPrettyPrinter => { __p.word("GdbPrettyPrinter") }
}
}
}
};PrintAttribute)]
360#[derive(#[automatically_derived]impl ::core::marker::Copy for DebuggerVisualizerType {
}Copy, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
DebuggerVisualizerType {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DebuggerVisualizerType
{
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::PartialOrd for
DebuggerVisualizerType {
#[inline]
fn partial_cmp(&self, other: &Self)
-> ::core::option::Option<::core::cmp::Ordering> {
::core::option::Option::Some(::core::cmp::Ord::cmp(self, other))
}
}PartialOrd, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for DebuggerVisualizerType {
}
#[automatically_derived]impl ::core::clone::Clone for DebuggerVisualizerType {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::cmp::Ord for DebuggerVisualizerType {
#[inline]
fn cmp(&self, other: &Self) -> ::core::cmp::Ordering {
::core::cmp::Ord::cmp(&::core::intrinsics::discriminant_value(self),
&::core::intrinsics::discriminant_value(other))
}
}Ord, #[automatically_derived]impl ::core::cmp::Eq for DebuggerVisualizerType { }Eq, #[automatically_derived]impl ::core::hash::Hash for DebuggerVisualizerType {
#[inline]
fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) {
::core::hash::Hash::hash(&::core::intrinsics::discriminant_value(self),
state)
}
}Hash, #[automatically_derived]impl ::core::fmt::Debug for DebuggerVisualizerType {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
DebuggerVisualizerType::Natvis => "Natvis",
DebuggerVisualizerType::GdbPrettyPrinter =>
"GdbPrettyPrinter",
})
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for DebuggerVisualizerType {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
DebuggerVisualizerType::Natvis => { 0usize }
DebuggerVisualizerType::GdbPrettyPrinter => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DebuggerVisualizerType {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { DebuggerVisualizerType::Natvis }
1usize => { DebuggerVisualizerType::GdbPrettyPrinter }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DebuggerVisualizerType`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable)]
361pub enum DebuggerVisualizerType {
362 Natvis,
363 GdbPrettyPrinter,
364}
365
366#[derive(#[automatically_derived]impl ::core::fmt::Debug for DebugVisualizer {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field3_finish(f,
"DebugVisualizer span visualizer_type path", &self.span,
&self.visualizer_type, &&self.path)
}
}Debug, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for DebugVisualizer {
fn encode(&self, __encoder: &mut __E) {
let DebugVisualizer {
span: ref __binding_0,
visualizer_type: ref __binding_1,
path: ref __binding_2 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DebugVisualizer {
fn decode(__decoder: &mut __D) -> Self {
DebugVisualizer {
span: ::rustc_serialize::Decodable::decode(__decoder),
visualizer_type: ::rustc_serialize::Decodable::decode(__decoder),
path: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, #[automatically_derived]impl ::core::clone::Clone for DebugVisualizer {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
DebugVisualizer {
span: ::core::clone::Clone::clone(&self.span),
visualizer_type: ::core::clone::Clone::clone(&self.visualizer_type),
path: ::core::clone::Clone::clone(&self.path),
}
}
}Clone, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
DebugVisualizer {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DebugVisualizer {
span: ref __binding_0,
visualizer_type: ref __binding_1,
path: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DebugVisualizer {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { span, visualizer_type, path } = self;
__p.word("DebugVisualizer");
if true && !span.should_render() &&
!visualizer_type.should_render() && !path.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if visualizer_type.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("visualizer_type");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
visualizer_type.print_attribute(__p);
if path.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("path");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
path.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
367pub struct DebugVisualizer {
368 pub span: Span,
369 pub visualizer_type: DebuggerVisualizerType,
370 pub path: Symbol,
371}
372
373#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for RtsanSetting {
}
#[automatically_derived]impl ::core::clone::Clone for RtsanSetting {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for RtsanSetting { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RtsanSetting {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
RtsanSetting::Nonblocking => "Nonblocking",
RtsanSetting::Blocking => "Blocking",
RtsanSetting::Caller => "Caller",
})
}
}Debug, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RtsanSetting {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { RtsanSetting::Nonblocking }
1usize => { RtsanSetting::Blocking }
2usize => { RtsanSetting::Caller }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RtsanSetting`, expected 0..3, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RtsanSetting {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
RtsanSetting::Nonblocking => { 0usize }
RtsanSetting::Blocking => { 1usize }
RtsanSetting::Caller => { 2usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, #[automatically_derived]impl ::core::cmp::Eq for RtsanSetting { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RtsanSetting {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RtsanSetting {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq)]
374#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for RtsanSetting
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RtsanSetting::Nonblocking =>
0u8.stable_hash(__hcx, __hasher),
RtsanSetting::Blocking => 1u8.stable_hash(__hcx, __hasher),
RtsanSetting::Caller => 2u8.stable_hash(__hcx, __hasher),
}
match *self {
RtsanSetting::Nonblocking => {}
RtsanSetting::Blocking => {}
RtsanSetting::Caller => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RtsanSetting {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Nonblocking => { __p.word("Nonblocking") }
Self::Blocking => { __p.word("Blocking") }
Self::Caller => { __p.word("Caller") }
}
}
}
};PrintAttribute)]
375#[derive_const(#[automatically_derived]const impl ::core::default::Default for RtsanSetting {
#[inline]
fn default() -> Self { Self::Caller }
}Default)]
376pub enum RtsanSetting {
377 Nonblocking,
378 Blocking,
379 #[default]
380 Caller,
381}
382
383#[derive(#[automatically_derived]impl ::core::cmp::Eq for WindowsSubsystemKind { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
WindowsSubsystemKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for WindowsSubsystemKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::fmt::Debug for WindowsSubsystemKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
WindowsSubsystemKind::Console => "Console",
WindowsSubsystemKind::Windows => "Windows",
})
}
}Debug, #[automatically_derived]impl ::core::marker::Copy for WindowsSubsystemKind { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for WindowsSubsystemKind {
}
#[automatically_derived]impl ::core::clone::Clone for WindowsSubsystemKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone)]
384#[derive(const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for WindowsSubsystemKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
WindowsSubsystemKind::Console => { 0usize }
WindowsSubsystemKind::Windows => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for WindowsSubsystemKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { WindowsSubsystemKind::Console }
1usize => { WindowsSubsystemKind::Windows }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `WindowsSubsystemKind`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
WindowsSubsystemKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
WindowsSubsystemKind::Console =>
0u8.stable_hash(__hcx, __hasher),
WindowsSubsystemKind::Windows =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
WindowsSubsystemKind::Console => {}
WindowsSubsystemKind::Windows => {}
}
}
}
};StableHash, const _: () =
{
#[allow(unused)]
impl PrintAttribute for WindowsSubsystemKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Console => { __p.word("Console") }
Self::Windows => { __p.word("Windows") }
}
}
}
};PrintAttribute)]
385pub enum WindowsSubsystemKind {
386 Console,
387 Windows,
388}
389
390impl WindowsSubsystemKind {
391 pub fn as_str(&self) -> &'static str {
392 match self {
393 WindowsSubsystemKind::Console => "console",
394 WindowsSubsystemKind::Windows => "windows",
395 }
396 }
397}
398
399#[derive(#[automatically_derived]impl ::core::marker::Copy for DocInline { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for DocInline {
}
#[automatically_derived]impl ::core::clone::Clone for DocInline {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocInline {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
DocInline::Inline => "Inline",
DocInline::NoInline => "NoInline",
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for DocInline
{
}
#[automatically_derived]impl ::core::cmp::PartialEq for DocInline {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq)]
400#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for DocInline {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DocInline::Inline => 0u8.stable_hash(__hcx, __hasher),
DocInline::NoInline => 1u8.stable_hash(__hcx, __hasher),
}
match *self {
DocInline::Inline => {}
DocInline::NoInline => {}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for DocInline {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
DocInline::Inline => { 0usize }
DocInline::NoInline => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DocInline {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { DocInline::Inline }
1usize => { DocInline::NoInline }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DocInline`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DocInline {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Inline => { __p.word("Inline") }
Self::NoInline => { __p.word("NoInline") }
}
}
}
};PrintAttribute)]
401pub enum DocInline {
402 Inline,
403 NoInline,
404}
405
406#[derive(#[automatically_derived]impl ::core::marker::Copy for HideOrShow { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for HideOrShow {
}
#[automatically_derived]impl ::core::clone::Clone for HideOrShow {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for HideOrShow {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
HideOrShow::Hide => "Hide",
HideOrShow::Show => "Show",
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
HideOrShow {
}
#[automatically_derived]impl ::core::cmp::PartialEq for HideOrShow {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq)]
407#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for HideOrShow {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
HideOrShow::Hide => 0u8.stable_hash(__hcx, __hasher),
HideOrShow::Show => 1u8.stable_hash(__hcx, __hasher),
}
match *self { HideOrShow::Hide => {} HideOrShow::Show => {} }
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for HideOrShow {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
HideOrShow::Hide => { 0usize }
HideOrShow::Show => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for HideOrShow {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { HideOrShow::Hide }
1usize => { HideOrShow::Show }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `HideOrShow`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for HideOrShow {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Hide => { __p.word("Hide") }
Self::Show => { __p.word("Show") }
}
}
}
};PrintAttribute)]
408pub enum HideOrShow {
409 Hide,
410 Show,
411}
412
413#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for DocCfgHideShowValue {
}
#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShowValue {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<Span>;
let _: ::core::clone::AssertParamIsClone<Option<Symbol>>;
*self
}
}Clone, #[automatically_derived]impl ::core::marker::Copy for DocCfgHideShowValue { }Copy, #[automatically_derived]impl ::core::fmt::Debug for DocCfgHideShowValue {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field2_finish(f,
"DocCfgHideShowValue span value", &self.span, &&self.value)
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
DocCfgHideShowValue {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DocCfgHideShowValue {
span: ref __binding_0, value: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for DocCfgHideShowValue {
fn encode(&self, __encoder: &mut __E) {
let DocCfgHideShowValue {
span: ref __binding_0, value: ref __binding_1 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DocCfgHideShowValue {
fn decode(__decoder: &mut __D) -> Self {
DocCfgHideShowValue {
span: ::rustc_serialize::Decodable::decode(__decoder),
value: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DocCfgHideShowValue {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { span, value } = self;
__p.word("DocCfgHideShowValue");
if true && !span.should_render() && !value.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if value.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("value");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
value.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
DocCfgHideShowValue {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DocCfgHideShowValue {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.span == other.span && self.value == other.value
}
}PartialEq)]
414pub struct DocCfgHideShowValue {
415 pub span: Span,
416 pub value: Option<Symbol>,
418}
419
420impl DocCfgHideShowValue {
421 pub fn new(value: Symbol, span: Span) -> Self {
422 Self { span, value: Some(value) }
423 }
424
425 pub fn new_none(span: Span) -> Self {
426 Self { span, value: None }
427 }
428}
429
430#[derive(#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShow {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
match self {
Self::Any(__self_0) =>
DocCfgHideShow::Any(::core::clone::Clone::clone(__self_0)),
Self::List(__self_0) =>
DocCfgHideShow::List(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocCfgHideShow {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Any(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Any",
&__self_0),
Self::List(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "List",
&__self_0),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
DocCfgHideShow {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DocCfgHideShow::Any(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
DocCfgHideShow::List(ref __binding_0) =>
1u8.stable_hash(__hcx, __hasher),
}
match *self {
DocCfgHideShow::Any(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
DocCfgHideShow::List(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for DocCfgHideShow {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
DocCfgHideShow::Any(ref __binding_0) => { 0usize }
DocCfgHideShow::List(ref __binding_0) => { 1usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
DocCfgHideShow::Any(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
DocCfgHideShow::List(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DocCfgHideShow {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
DocCfgHideShow::Any(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => {
DocCfgHideShow::List(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `DocCfgHideShow`, expected 0..2, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DocCfgHideShow {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Any(f0) => {
__p.word("Any");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::List(f0) => {
__p.word("List");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
DocCfgHideShow {
}
#[automatically_derived]impl ::core::cmp::PartialEq for DocCfgHideShow {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Any(__self_0), Self::Any(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::List(__self_0), Self::List(__arg1_0)) =>
__self_0 == __arg1_0,
_ => unsafe { ::core::intrinsics::unreachable() }
}
}
}PartialEq)]
431pub enum DocCfgHideShow {
432 Any(Span),
433 List(ThinVec<DocCfgHideShowValue>),
434}
435
436impl DocCfgHideShow {
437 pub fn new() -> Self {
438 Self::List(ThinVec::new())
439 }
440
441 pub fn new_with_only_key(span: Span) -> Self {
442 let mut values = ThinVec::with_capacity(1);
443 values.push(DocCfgHideShowValue { span, value: None });
444 Self::List(values)
445 }
446
447 pub fn push_none(&mut self, span: Span) {
448 if let Self::List(values) = self
449 && !values.iter().any(|v| v.value.is_none())
450 {
451 values.push(DocCfgHideShowValue { span, value: None });
452 }
453 }
454
455 pub fn merge_with(&mut self, other: &Self) {
456 match (self, other) {
457 (Self::Any(_), Self::Any(_) | Self::List(_)) => {
458 }
460 (s, Self::Any(span)) => {
461 *s = Self::Any(*span);
463 }
464 (Self::List(values), Self::List(other_values)) => {
465 for other in other_values {
468 if !values.iter().any(|value| value.value == other.value) {
469 values.push(*other);
470 }
471 }
472 }
473 }
474 }
475}
476
477#[derive(#[automatically_derived]impl ::core::clone::Clone for CfgHideShow {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
CfgHideShow {
kind: ::core::clone::Clone::clone(&self.kind),
values: ::core::clone::Clone::clone(&self.values),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for CfgHideShow {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field2_finish(f,
"CfgHideShow kind values", &self.kind, &&self.values)
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for CfgHideShow
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
CfgHideShow { kind: ref __binding_0, values: ref __binding_1
} => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for CfgHideShow {
fn encode(&self, __encoder: &mut __E) {
let CfgHideShow {
kind: ref __binding_0, values: ref __binding_1 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for CfgHideShow {
fn decode(__decoder: &mut __D) -> Self {
CfgHideShow {
kind: ::rustc_serialize::Decodable::decode(__decoder),
values: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for CfgHideShow {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { kind, values } = self;
__p.word("CfgHideShow");
if true && !kind.should_render() && !values.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if kind.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("kind");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
kind.print_attribute(__p);
if values.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("values");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
values.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
478pub struct CfgHideShow {
479 pub kind: HideOrShow,
480 pub values: FxIndexMap<Symbol, DocCfgHideShow>,
481}
482
483#[derive(#[automatically_derived]impl ::core::clone::Clone for DocAttribute {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
DocAttribute {
first_span: ::core::clone::Clone::clone(&self.first_span),
aliases: ::core::clone::Clone::clone(&self.aliases),
hidden: ::core::clone::Clone::clone(&self.hidden),
inline: ::core::clone::Clone::clone(&self.inline),
cfg: ::core::clone::Clone::clone(&self.cfg),
auto_cfg: ::core::clone::Clone::clone(&self.auto_cfg),
auto_cfg_change: ::core::clone::Clone::clone(&self.auto_cfg_change),
fake_variadic: ::core::clone::Clone::clone(&self.fake_variadic),
keyword: ::core::clone::Clone::clone(&self.keyword),
attribute: ::core::clone::Clone::clone(&self.attribute),
masked: ::core::clone::Clone::clone(&self.masked),
notable_trait: ::core::clone::Clone::clone(&self.notable_trait),
search_unbox: ::core::clone::Clone::clone(&self.search_unbox),
html_favicon_url: ::core::clone::Clone::clone(&self.html_favicon_url),
html_logo_url: ::core::clone::Clone::clone(&self.html_logo_url),
html_playground_url: ::core::clone::Clone::clone(&self.html_playground_url),
html_root_url: ::core::clone::Clone::clone(&self.html_root_url),
html_no_source: ::core::clone::Clone::clone(&self.html_no_source),
issue_tracker_base_url: ::core::clone::Clone::clone(&self.issue_tracker_base_url),
rust_logo: ::core::clone::Clone::clone(&self.rust_logo),
test_attrs: ::core::clone::Clone::clone(&self.test_attrs),
no_crate_inject: ::core::clone::Clone::clone(&self.no_crate_inject),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocAttribute {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
let names: &'static _ =
"DocAttribute first_span aliases hidden inline cfg auto_cfg auto_cfg_change fake_variadic keyword attribute masked notable_trait search_unbox html_favicon_url html_logo_url html_playground_url html_root_url html_no_source issue_tracker_base_url rust_logo test_attrs no_crate_inject";
let values: &[&dyn ::core::fmt::Debug] =
&[&self.first_span, &self.aliases, &self.hidden, &self.inline,
&self.cfg, &self.auto_cfg, &self.auto_cfg_change,
&self.fake_variadic, &self.keyword, &self.attribute,
&self.masked, &self.notable_trait, &self.search_unbox,
&self.html_favicon_url, &self.html_logo_url,
&self.html_playground_url, &self.html_root_url,
&self.html_no_source, &self.issue_tracker_base_url,
&self.rust_logo, &self.test_attrs, &&self.no_crate_inject];
::core::fmt::Formatter::debug_struct_fields_finish(f, names, values)
}
}Debug, #[automatically_derived]impl ::core::default::Default for DocAttribute {
#[inline]
fn default() -> Self {
DocAttribute {
first_span: ::core::default::Default::default(),
aliases: ::core::default::Default::default(),
hidden: ::core::default::Default::default(),
inline: ::core::default::Default::default(),
cfg: ::core::default::Default::default(),
auto_cfg: ::core::default::Default::default(),
auto_cfg_change: ::core::default::Default::default(),
fake_variadic: ::core::default::Default::default(),
keyword: ::core::default::Default::default(),
attribute: ::core::default::Default::default(),
masked: ::core::default::Default::default(),
notable_trait: ::core::default::Default::default(),
search_unbox: ::core::default::Default::default(),
html_favicon_url: ::core::default::Default::default(),
html_logo_url: ::core::default::Default::default(),
html_playground_url: ::core::default::Default::default(),
html_root_url: ::core::default::Default::default(),
html_no_source: ::core::default::Default::default(),
issue_tracker_base_url: ::core::default::Default::default(),
rust_logo: ::core::default::Default::default(),
test_attrs: ::core::default::Default::default(),
no_crate_inject: ::core::default::Default::default(),
}
}
}Default, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for DocAttribute
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
DocAttribute {
first_span: ref __binding_0,
aliases: ref __binding_1,
hidden: ref __binding_2,
inline: ref __binding_3,
cfg: ref __binding_4,
auto_cfg: ref __binding_5,
auto_cfg_change: ref __binding_6,
fake_variadic: ref __binding_7,
keyword: ref __binding_8,
attribute: ref __binding_9,
masked: ref __binding_10,
notable_trait: ref __binding_11,
search_unbox: ref __binding_12,
html_favicon_url: ref __binding_13,
html_logo_url: ref __binding_14,
html_playground_url: ref __binding_15,
html_root_url: ref __binding_16,
html_no_source: ref __binding_17,
issue_tracker_base_url: ref __binding_18,
rust_logo: ref __binding_19,
test_attrs: ref __binding_20,
no_crate_inject: ref __binding_21 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
{ __binding_4.stable_hash(__hcx, __hasher); }
{ __binding_5.stable_hash(__hcx, __hasher); }
{ __binding_6.stable_hash(__hcx, __hasher); }
{ __binding_7.stable_hash(__hcx, __hasher); }
{ __binding_8.stable_hash(__hcx, __hasher); }
{ __binding_9.stable_hash(__hcx, __hasher); }
{ __binding_10.stable_hash(__hcx, __hasher); }
{ __binding_11.stable_hash(__hcx, __hasher); }
{ __binding_12.stable_hash(__hcx, __hasher); }
{ __binding_13.stable_hash(__hcx, __hasher); }
{ __binding_14.stable_hash(__hcx, __hasher); }
{ __binding_15.stable_hash(__hcx, __hasher); }
{ __binding_16.stable_hash(__hcx, __hasher); }
{ __binding_17.stable_hash(__hcx, __hasher); }
{ __binding_18.stable_hash(__hcx, __hasher); }
{ __binding_19.stable_hash(__hcx, __hasher); }
{ __binding_20.stable_hash(__hcx, __hasher); }
{ __binding_21.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for DocAttribute {
fn decode(__decoder: &mut __D) -> Self {
DocAttribute {
first_span: ::rustc_serialize::Decodable::decode(__decoder),
aliases: ::rustc_serialize::Decodable::decode(__decoder),
hidden: ::rustc_serialize::Decodable::decode(__decoder),
inline: ::rustc_serialize::Decodable::decode(__decoder),
cfg: ::rustc_serialize::Decodable::decode(__decoder),
auto_cfg: ::rustc_serialize::Decodable::decode(__decoder),
auto_cfg_change: ::rustc_serialize::Decodable::decode(__decoder),
fake_variadic: ::rustc_serialize::Decodable::decode(__decoder),
keyword: ::rustc_serialize::Decodable::decode(__decoder),
attribute: ::rustc_serialize::Decodable::decode(__decoder),
masked: ::rustc_serialize::Decodable::decode(__decoder),
notable_trait: ::rustc_serialize::Decodable::decode(__decoder),
search_unbox: ::rustc_serialize::Decodable::decode(__decoder),
html_favicon_url: ::rustc_serialize::Decodable::decode(__decoder),
html_logo_url: ::rustc_serialize::Decodable::decode(__decoder),
html_playground_url: ::rustc_serialize::Decodable::decode(__decoder),
html_root_url: ::rustc_serialize::Decodable::decode(__decoder),
html_no_source: ::rustc_serialize::Decodable::decode(__decoder),
issue_tracker_base_url: ::rustc_serialize::Decodable::decode(__decoder),
rust_logo: ::rustc_serialize::Decodable::decode(__decoder),
test_attrs: ::rustc_serialize::Decodable::decode(__decoder),
no_crate_inject: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for DocAttribute {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self {
first_span,
aliases,
hidden,
inline,
cfg,
auto_cfg,
auto_cfg_change,
fake_variadic,
keyword,
attribute,
masked,
notable_trait,
search_unbox,
html_favicon_url,
html_logo_url,
html_playground_url,
html_root_url,
html_no_source,
issue_tracker_base_url,
rust_logo,
test_attrs,
no_crate_inject } = self;
__p.word("DocAttribute");
if true && !first_span.should_render() &&
!aliases.should_render() && !hidden.should_render() &&
!inline.should_render() && !cfg.should_render() &&
!auto_cfg.should_render() &&
!auto_cfg_change.should_render() &&
!fake_variadic.should_render() && !keyword.should_render()
&& !attribute.should_render() && !masked.should_render() &&
!notable_trait.should_render() &&
!search_unbox.should_render() &&
!html_favicon_url.should_render() &&
!html_logo_url.should_render() &&
!html_playground_url.should_render() &&
!html_root_url.should_render() &&
!html_no_source.should_render() &&
!issue_tracker_base_url.should_render() &&
!rust_logo.should_render() && !test_attrs.should_render() &&
!no_crate_inject.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if first_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("first_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
first_span.print_attribute(__p);
if aliases.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("aliases");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
aliases.print_attribute(__p);
if hidden.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("hidden");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
hidden.print_attribute(__p);
if inline.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("inline");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
inline.print_attribute(__p);
if cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
cfg.print_attribute(__p);
if auto_cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("auto_cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
auto_cfg.print_attribute(__p);
if auto_cfg_change.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("auto_cfg_change");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
auto_cfg_change.print_attribute(__p);
if fake_variadic.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("fake_variadic");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
fake_variadic.print_attribute(__p);
if keyword.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("keyword");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
keyword.print_attribute(__p);
if attribute.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attribute");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attribute.print_attribute(__p);
if masked.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("masked");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
masked.print_attribute(__p);
if notable_trait.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("notable_trait");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
notable_trait.print_attribute(__p);
if search_unbox.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("search_unbox");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
search_unbox.print_attribute(__p);
if html_favicon_url.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("html_favicon_url");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
html_favicon_url.print_attribute(__p);
if html_logo_url.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("html_logo_url");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
html_logo_url.print_attribute(__p);
if html_playground_url.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("html_playground_url");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
html_playground_url.print_attribute(__p);
if html_root_url.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("html_root_url");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
html_root_url.print_attribute(__p);
if html_no_source.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("html_no_source");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
html_no_source.print_attribute(__p);
if issue_tracker_base_url.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("issue_tracker_base_url");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
issue_tracker_base_url.print_attribute(__p);
if rust_logo.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("rust_logo");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
rust_logo.print_attribute(__p);
if test_attrs.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("test_attrs");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
test_attrs.print_attribute(__p);
if no_crate_inject.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("no_crate_inject");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
no_crate_inject.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
484pub struct DocAttribute {
485 pub first_span: Span,
486
487 pub aliases: FxIndexMap<Symbol, Span>,
488 pub hidden: Option<Span>,
489 pub inline: Option<(DocInline, Span)>,
490
491 pub cfg: ThinVec<CfgEntry>,
493 pub auto_cfg: ThinVec<(CfgHideShow, Span)>,
494 pub auto_cfg_change: ThinVec<(bool, Span)>,
496
497 pub fake_variadic: Option<Span>,
499 pub keyword: Option<(Symbol, Span)>,
500 pub attribute: Option<(Symbol, Span)>,
501 pub masked: Option<Span>,
502 pub notable_trait: Option<(Option<(NotableTraitColor, Span)>, Span)>,
503 pub search_unbox: Option<Span>,
504
505 pub html_favicon_url: Option<(Symbol, Span)>,
507 pub html_logo_url: Option<(Symbol, Span)>,
508 pub html_playground_url: Option<(Symbol, Span)>,
509 pub html_root_url: Option<(Symbol, Span)>,
510 pub html_no_source: Option<Span>,
511 pub issue_tracker_base_url: Option<(Symbol, Span)>,
512 pub rust_logo: Option<Span>,
513
514 pub test_attrs: ThinVec<Span>,
516 pub no_crate_inject: Option<Span>,
517}
518
519#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for NotableTraitColor {
}
#[automatically_derived]impl ::core::clone::Clone for NotableTraitColor {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for NotableTraitColor { }Copy, #[automatically_derived]impl ::core::fmt::Debug for NotableTraitColor {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_c_like_enum_write_str(f,
"Grey Red Green Yellow Blue Magenta Cyan Transparent",
match self {
NotableTraitColor::Grey => 0usize,
NotableTraitColor::Red => 5usize,
NotableTraitColor::Green => 9usize,
NotableTraitColor::Yellow => 15usize,
NotableTraitColor::Blue => 22usize,
NotableTraitColor::Magenta => 27usize,
NotableTraitColor::Cyan => 35usize,
NotableTraitColor::Transparent => 40usize,
})
}
}Debug, #[automatically_derived]impl ::core::cmp::Eq for NotableTraitColor { }Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
NotableTraitColor {
}
#[automatically_derived]impl ::core::cmp::PartialEq for NotableTraitColor {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq)]
520#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
NotableTraitColor {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
NotableTraitColor::Grey => 0u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Red => 1u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Green =>
2u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Yellow =>
3u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Blue => 4u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Magenta =>
5u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Cyan => 6u8.stable_hash(__hcx, __hasher),
NotableTraitColor::Transparent =>
7u8.stable_hash(__hcx, __hasher),
}
match *self {
NotableTraitColor::Grey => {}
NotableTraitColor::Red => {}
NotableTraitColor::Green => {}
NotableTraitColor::Yellow => {}
NotableTraitColor::Blue => {}
NotableTraitColor::Magenta => {}
NotableTraitColor::Cyan => {}
NotableTraitColor::Transparent => {}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for NotableTraitColor {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
NotableTraitColor::Grey => { 0usize }
NotableTraitColor::Red => { 1usize }
NotableTraitColor::Green => { 2usize }
NotableTraitColor::Yellow => { 3usize }
NotableTraitColor::Blue => { 4usize }
NotableTraitColor::Magenta => { 5usize }
NotableTraitColor::Cyan => { 6usize }
NotableTraitColor::Transparent => { 7usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for NotableTraitColor {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { NotableTraitColor::Grey }
1usize => { NotableTraitColor::Red }
2usize => { NotableTraitColor::Green }
3usize => { NotableTraitColor::Yellow }
4usize => { NotableTraitColor::Blue }
5usize => { NotableTraitColor::Magenta }
6usize => { NotableTraitColor::Cyan }
7usize => { NotableTraitColor::Transparent }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `NotableTraitColor`, expected 0..8, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for NotableTraitColor {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Grey => { __p.word("Grey") }
Self::Red => { __p.word("Red") }
Self::Green => { __p.word("Green") }
Self::Yellow => { __p.word("Yellow") }
Self::Blue => { __p.word("Blue") }
Self::Magenta => { __p.word("Magenta") }
Self::Cyan => { __p.word("Cyan") }
Self::Transparent => { __p.word("Transparent") }
}
}
}
};PrintAttribute)]
521pub enum NotableTraitColor {
522 Grey,
523 Red,
524 Green,
525 Yellow,
526 Blue,
527 Magenta,
528 Cyan,
529 Transparent,
530}
531
532impl From<NotableTraitColor> for &'static str {
533 fn from(color: NotableTraitColor) -> &'static str {
534 use NotableTraitColor::*;
535 match color {
536 Grey => "grey",
537 Red => "red",
538 Green => "green",
539 Yellow => "yellow",
540 Blue => "blue",
541 Magenta => "magenta",
542 Cyan => "cyan",
543 Transparent => "transparent",
544 }
545 }
546}
547
548impl std::fmt::Display for NotableTraitColor {
549 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
550 f.write_str((*self).into())
551 }
552}
553
554impl<E: rustc_span::SpanEncoder> rustc_serialize::Encodable<E> for DocAttribute {
555 fn encode(&self, encoder: &mut E) {
556 let DocAttribute {
557 first_span,
558 aliases,
559 hidden,
560 inline,
561 cfg,
562 auto_cfg,
563 auto_cfg_change,
564 fake_variadic,
565 keyword,
566 attribute,
567 masked,
568 notable_trait,
569 search_unbox,
570 html_favicon_url,
571 html_logo_url,
572 html_playground_url,
573 html_root_url,
574 html_no_source,
575 issue_tracker_base_url,
576 rust_logo,
577 test_attrs,
578 no_crate_inject,
579 } = self;
580 rustc_serialize::Encodable::<E>::encode(first_span, encoder);
581 rustc_serialize::Encodable::<E>::encode(aliases, encoder);
582 rustc_serialize::Encodable::<E>::encode(hidden, encoder);
583
584 let inline = inline.filter(|(i, _)| *i != DocInline::Inline);
588 rustc_serialize::Encodable::<E>::encode(&inline, encoder);
589
590 rustc_serialize::Encodable::<E>::encode(cfg, encoder);
591 rustc_serialize::Encodable::<E>::encode(auto_cfg, encoder);
592 rustc_serialize::Encodable::<E>::encode(auto_cfg_change, encoder);
593 rustc_serialize::Encodable::<E>::encode(fake_variadic, encoder);
594 rustc_serialize::Encodable::<E>::encode(keyword, encoder);
595 rustc_serialize::Encodable::<E>::encode(attribute, encoder);
596 rustc_serialize::Encodable::<E>::encode(masked, encoder);
597 rustc_serialize::Encodable::<E>::encode(notable_trait, encoder);
598 rustc_serialize::Encodable::<E>::encode(search_unbox, encoder);
599 rustc_serialize::Encodable::<E>::encode(html_favicon_url, encoder);
600 rustc_serialize::Encodable::<E>::encode(html_logo_url, encoder);
601 rustc_serialize::Encodable::<E>::encode(html_playground_url, encoder);
602 rustc_serialize::Encodable::<E>::encode(html_root_url, encoder);
603 rustc_serialize::Encodable::<E>::encode(html_no_source, encoder);
604 rustc_serialize::Encodable::<E>::encode(issue_tracker_base_url, encoder);
605 rustc_serialize::Encodable::<E>::encode(rust_logo, encoder);
606 rustc_serialize::Encodable::<E>::encode(test_attrs, encoder);
607 rustc_serialize::Encodable::<E>::encode(no_crate_inject, encoder);
608 }
609}
610
611#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcShowSpansKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
match self {
Self::Expr => RustcShowSpansKind::Expr,
Self::Ty => RustcShowSpansKind::Ty,
Self::Path => RustcShowSpansKind::Path,
Self::GenericArgs => RustcShowSpansKind::GenericArgs,
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcShowSpansKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
RustcShowSpansKind::Expr => "Expr",
RustcShowSpansKind::Ty => "Ty",
RustcShowSpansKind::Path => "Path",
RustcShowSpansKind::GenericArgs => "GenericArgs",
})
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcShowSpansKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcShowSpansKind::Expr =>
0u8.stable_hash(__hcx, __hasher),
RustcShowSpansKind::Ty => 1u8.stable_hash(__hcx, __hasher),
RustcShowSpansKind::Path =>
2u8.stable_hash(__hcx, __hasher),
RustcShowSpansKind::GenericArgs =>
3u8.stable_hash(__hcx, __hasher),
}
match *self {
RustcShowSpansKind::Expr => {}
RustcShowSpansKind::Ty => {}
RustcShowSpansKind::Path => {}
RustcShowSpansKind::GenericArgs => {}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcShowSpansKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
RustcShowSpansKind::Expr => { 0usize }
RustcShowSpansKind::Ty => { 1usize }
RustcShowSpansKind::Path => { 2usize }
RustcShowSpansKind::GenericArgs => { 3usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcShowSpansKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { RustcShowSpansKind::Expr }
1usize => { RustcShowSpansKind::Ty }
2usize => { RustcShowSpansKind::Path }
3usize => { RustcShowSpansKind::GenericArgs }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcShowSpansKind`, expected 0..4, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcShowSpansKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Expr => { __p.word("Expr") }
Self::Ty => { __p.word("Ty") }
Self::Path => { __p.word("Path") }
Self::GenericArgs => { __p.word("GenericArgs") }
}
}
}
};PrintAttribute)]
612pub enum RustcShowSpansKind {
613 Expr,
614 Ty,
615 Path,
616 GenericArgs,
617}
618
619#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcDumpLayoutKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
match self {
Self::Align => RustcDumpLayoutKind::Align,
Self::BackendRepr => RustcDumpLayoutKind::BackendRepr,
Self::Debug => RustcDumpLayoutKind::Debug,
Self::HomogenousAggregate =>
RustcDumpLayoutKind::HomogenousAggregate,
Self::LargestNiche => RustcDumpLayoutKind::LargestNiche,
Self::Size => RustcDumpLayoutKind::Size,
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcDumpLayoutKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_c_like_enum_write_str(f,
"Align BackendRepr Debug HomogenousAggregate LargestNiche Size",
match self {
RustcDumpLayoutKind::Align => 0usize,
RustcDumpLayoutKind::BackendRepr => 6usize,
RustcDumpLayoutKind::Debug => 18usize,
RustcDumpLayoutKind::HomogenousAggregate => 24usize,
RustcDumpLayoutKind::LargestNiche => 44usize,
RustcDumpLayoutKind::Size => 57usize,
})
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcDumpLayoutKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcDumpLayoutKind::Align =>
0u8.stable_hash(__hcx, __hasher),
RustcDumpLayoutKind::BackendRepr =>
1u8.stable_hash(__hcx, __hasher),
RustcDumpLayoutKind::Debug =>
2u8.stable_hash(__hcx, __hasher),
RustcDumpLayoutKind::HomogenousAggregate =>
3u8.stable_hash(__hcx, __hasher),
RustcDumpLayoutKind::LargestNiche =>
4u8.stable_hash(__hcx, __hasher),
RustcDumpLayoutKind::Size =>
5u8.stable_hash(__hcx, __hasher),
}
match *self {
RustcDumpLayoutKind::Align => {}
RustcDumpLayoutKind::BackendRepr => {}
RustcDumpLayoutKind::Debug => {}
RustcDumpLayoutKind::HomogenousAggregate => {}
RustcDumpLayoutKind::LargestNiche => {}
RustcDumpLayoutKind::Size => {}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcDumpLayoutKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
RustcDumpLayoutKind::Align => { 0usize }
RustcDumpLayoutKind::BackendRepr => { 1usize }
RustcDumpLayoutKind::Debug => { 2usize }
RustcDumpLayoutKind::HomogenousAggregate => { 3usize }
RustcDumpLayoutKind::LargestNiche => { 4usize }
RustcDumpLayoutKind::Size => { 5usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcDumpLayoutKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { RustcDumpLayoutKind::Align }
1usize => { RustcDumpLayoutKind::BackendRepr }
2usize => { RustcDumpLayoutKind::Debug }
3usize => { RustcDumpLayoutKind::HomogenousAggregate }
4usize => { RustcDumpLayoutKind::LargestNiche }
5usize => { RustcDumpLayoutKind::Size }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcDumpLayoutKind`, expected 0..6, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcDumpLayoutKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Align => { __p.word("Align") }
Self::BackendRepr => { __p.word("BackendRepr") }
Self::Debug => { __p.word("Debug") }
Self::HomogenousAggregate => {
__p.word("HomogenousAggregate")
}
Self::LargestNiche => { __p.word("LargestNiche") }
Self::Size => { __p.word("Size") }
}
}
}
};PrintAttribute)]
620pub enum RustcDumpLayoutKind {
621 Align,
622 BackendRepr,
623 Debug,
624 HomogenousAggregate,
625 LargestNiche,
626 Size,
627}
628
629#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcMirKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
match self {
Self::PrettyLiveLocals => RustcMirKind::PrettyLiveLocals,
Self::PrettyPreciseLiveness =>
RustcMirKind::PrettyPreciseLiveness,
Self::PrettyTransitiveLiveLocals =>
RustcMirKind::PrettyTransitiveLiveLocals,
Self::PeekMaybeInit => RustcMirKind::PeekMaybeInit,
Self::PeekMaybeUninit => RustcMirKind::PeekMaybeUninit,
Self::PeekLiveness => RustcMirKind::PeekLiveness,
Self::StopAfterDataflow => RustcMirKind::StopAfterDataflow,
Self::BorrowckGraphvizPostflow { path: __self_0 } =>
RustcMirKind::BorrowckGraphvizPostflow {
path: ::core::clone::Clone::clone(__self_0),
},
Self::BorrowckGraphvizFormat { format: __self_0 } =>
RustcMirKind::BorrowckGraphvizFormat {
format: ::core::clone::Clone::clone(__self_0),
},
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcMirKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::PrettyLiveLocals =>
::core::fmt::Formatter::write_str(f, "PrettyLiveLocals"),
Self::PrettyPreciseLiveness =>
::core::fmt::Formatter::write_str(f, "PrettyPreciseLiveness"),
Self::PrettyTransitiveLiveLocals =>
::core::fmt::Formatter::write_str(f,
"PrettyTransitiveLiveLocals"),
Self::PeekMaybeInit =>
::core::fmt::Formatter::write_str(f, "PeekMaybeInit"),
Self::PeekMaybeUninit =>
::core::fmt::Formatter::write_str(f, "PeekMaybeUninit"),
Self::PeekLiveness =>
::core::fmt::Formatter::write_str(f, "PeekLiveness"),
Self::StopAfterDataflow =>
::core::fmt::Formatter::write_str(f, "StopAfterDataflow"),
Self::BorrowckGraphvizPostflow { path: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"BorrowckGraphvizPostflow path", &__self_0),
Self::BorrowckGraphvizFormat { format: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"BorrowckGraphvizFormat format", &__self_0),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for RustcMirKind
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcMirKind::PrettyLiveLocals =>
0u8.stable_hash(__hcx, __hasher),
RustcMirKind::PrettyPreciseLiveness =>
1u8.stable_hash(__hcx, __hasher),
RustcMirKind::PrettyTransitiveLiveLocals =>
2u8.stable_hash(__hcx, __hasher),
RustcMirKind::PeekMaybeInit =>
3u8.stable_hash(__hcx, __hasher),
RustcMirKind::PeekMaybeUninit =>
4u8.stable_hash(__hcx, __hasher),
RustcMirKind::PeekLiveness =>
5u8.stable_hash(__hcx, __hasher),
RustcMirKind::StopAfterDataflow =>
6u8.stable_hash(__hcx, __hasher),
RustcMirKind::BorrowckGraphvizPostflow {
path: ref __binding_0 } => 7u8.stable_hash(__hcx, __hasher),
RustcMirKind::BorrowckGraphvizFormat {
format: ref __binding_0 } =>
8u8.stable_hash(__hcx, __hasher),
}
match *self {
RustcMirKind::PrettyLiveLocals => {}
RustcMirKind::PrettyPreciseLiveness => {}
RustcMirKind::PrettyTransitiveLiveLocals => {}
RustcMirKind::PeekMaybeInit => {}
RustcMirKind::PeekMaybeUninit => {}
RustcMirKind::PeekLiveness => {}
RustcMirKind::StopAfterDataflow => {}
RustcMirKind::BorrowckGraphvizPostflow {
path: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
RustcMirKind::BorrowckGraphvizFormat {
format: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcMirKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
RustcMirKind::PrettyLiveLocals => { 0usize }
RustcMirKind::PrettyPreciseLiveness => { 1usize }
RustcMirKind::PrettyTransitiveLiveLocals => { 2usize }
RustcMirKind::PeekMaybeInit => { 3usize }
RustcMirKind::PeekMaybeUninit => { 4usize }
RustcMirKind::PeekLiveness => { 5usize }
RustcMirKind::StopAfterDataflow => { 6usize }
RustcMirKind::BorrowckGraphvizPostflow {
path: ref __binding_0 } => {
7usize
}
RustcMirKind::BorrowckGraphvizFormat {
format: ref __binding_0 } => {
8usize
}
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
RustcMirKind::PrettyLiveLocals => {}
RustcMirKind::PrettyPreciseLiveness => {}
RustcMirKind::PrettyTransitiveLiveLocals => {}
RustcMirKind::PeekMaybeInit => {}
RustcMirKind::PeekMaybeUninit => {}
RustcMirKind::PeekLiveness => {}
RustcMirKind::StopAfterDataflow => {}
RustcMirKind::BorrowckGraphvizPostflow {
path: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
RustcMirKind::BorrowckGraphvizFormat {
format: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcMirKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { RustcMirKind::PrettyLiveLocals }
1usize => { RustcMirKind::PrettyPreciseLiveness }
2usize => { RustcMirKind::PrettyTransitiveLiveLocals }
3usize => { RustcMirKind::PeekMaybeInit }
4usize => { RustcMirKind::PeekMaybeUninit }
5usize => { RustcMirKind::PeekLiveness }
6usize => { RustcMirKind::StopAfterDataflow }
7usize => {
RustcMirKind::BorrowckGraphvizPostflow {
path: ::rustc_serialize::Decodable::decode(__decoder),
}
}
8usize => {
RustcMirKind::BorrowckGraphvizFormat {
format: ::rustc_serialize::Decodable::decode(__decoder),
}
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcMirKind`, expected 0..9, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcMirKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::PrettyLiveLocals => { __p.word("PrettyLiveLocals") }
Self::PrettyPreciseLiveness => {
__p.word("PrettyPreciseLiveness")
}
Self::PrettyTransitiveLiveLocals => {
__p.word("PrettyTransitiveLiveLocals")
}
Self::PeekMaybeInit => { __p.word("PeekMaybeInit") }
Self::PeekMaybeUninit => { __p.word("PeekMaybeUninit") }
Self::PeekLiveness => { __p.word("PeekLiveness") }
Self::StopAfterDataflow => { __p.word("StopAfterDataflow") }
Self::BorrowckGraphvizPostflow { path } => {
__p.word("BorrowckGraphvizPostflow");
if true && !path.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if path.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("path");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
path.print_attribute(__p);
__p.word("}");
}
Self::BorrowckGraphvizFormat { format } => {
__p.word("BorrowckGraphvizFormat");
if true && !format.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if format.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("format");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
format.print_attribute(__p);
__p.word("}");
}
}
}
}
};PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RustcMirKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcMirKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::BorrowckGraphvizPostflow { path: __self_0 },
Self::BorrowckGraphvizPostflow { path: __arg1_0 }) =>
__self_0 == __arg1_0,
(Self::BorrowckGraphvizFormat { format: __self_0 },
Self::BorrowckGraphvizFormat { format: __arg1_0 }) =>
__self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcMirKind {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<PathBuf>;
let _: ::core::cmp::AssertParamIsEq<BorrowckGraphvizFormatKind>;
}
}Eq)]
630pub enum RustcMirKind {
631 PrettyLiveLocals,
632 PrettyPreciseLiveness,
633 PrettyTransitiveLiveLocals,
634 PeekMaybeInit,
635 PeekMaybeUninit,
636 PeekLiveness,
637 StopAfterDataflow,
638 BorrowckGraphvizPostflow { path: PathBuf },
639 BorrowckGraphvizFormat { format: BorrowckGraphvizFormatKind },
640}
641
642#[derive(#[automatically_derived]impl ::core::clone::Clone for
BorrowckGraphvizFormatKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { BorrowckGraphvizFormatKind::TwoPhase }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for BorrowckGraphvizFormatKind
{
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f, "TwoPhase")
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
BorrowckGraphvizFormatKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
BorrowckGraphvizFormatKind::TwoPhase =>
0u8.stable_hash(__hcx, __hasher),
}
match *self { BorrowckGraphvizFormatKind::TwoPhase => {} }
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for BorrowckGraphvizFormatKind {
fn encode(&self, __encoder: &mut __E) {}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for BorrowckGraphvizFormatKind {
fn decode(__decoder: &mut __D) -> Self {
BorrowckGraphvizFormatKind::TwoPhase
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for BorrowckGraphvizFormatKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self { Self::TwoPhase => { __p.word("TwoPhase") } }
}
}
};PrintAttribute, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
BorrowckGraphvizFormatKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for
BorrowckGraphvizFormatKind {
#[inline]
fn eq(&self, other: &Self) -> bool { true }
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for BorrowckGraphvizFormatKind {
}Eq)]
643pub enum BorrowckGraphvizFormatKind {
644 TwoPhase,
645}
646
647#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanAttribute {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
RustcCleanAttribute {
span: ::core::clone::Clone::clone(&self.span),
cfg: ::core::clone::Clone::clone(&self.cfg),
except: ::core::clone::Clone::clone(&self.except),
loaded_from_disk: ::core::clone::Clone::clone(&self.loaded_from_disk),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcCleanAttribute {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field4_finish(f,
"RustcCleanAttribute span cfg except loaded_from_disk",
&self.span, &self.cfg, &self.except, &&self.loaded_from_disk)
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RustcCleanAttribute {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcCleanAttribute {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.span == other.span && self.cfg == other.cfg &&
self.except == other.except &&
self.loaded_from_disk == other.loaded_from_disk
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcCleanAttribute {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<Span>;
let _: ::core::cmp::AssertParamIsEq<Symbol>;
let _: ::core::cmp::AssertParamIsEq<Option<RustcCleanQueries>>;
let _: ::core::cmp::AssertParamIsEq<Option<RustcCleanQueries>>;
}
}Eq)]
648#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcCleanAttribute {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcCleanAttribute {
span: ref __binding_0,
cfg: ref __binding_1,
except: ref __binding_2,
loaded_from_disk: ref __binding_3 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcCleanAttribute {
fn encode(&self, __encoder: &mut __E) {
let RustcCleanAttribute {
span: ref __binding_0,
cfg: ref __binding_1,
except: ref __binding_2,
loaded_from_disk: ref __binding_3 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcCleanAttribute {
fn decode(__decoder: &mut __D) -> Self {
RustcCleanAttribute {
span: ::rustc_serialize::Decodable::decode(__decoder),
cfg: ::rustc_serialize::Decodable::decode(__decoder),
except: ::rustc_serialize::Decodable::decode(__decoder),
loaded_from_disk: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcCleanAttribute {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { span, cfg, except, loaded_from_disk } = self;
__p.word("RustcCleanAttribute");
if true && !span.should_render() && !cfg.should_render() &&
!except.should_render() && !loaded_from_disk.should_render()
{
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if cfg.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("cfg");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
cfg.print_attribute(__p);
if except.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("except");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
except.print_attribute(__p);
if loaded_from_disk.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("loaded_from_disk");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
loaded_from_disk.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
649pub struct RustcCleanAttribute {
650 pub span: Span,
651 pub cfg: Symbol,
652 pub except: Option<RustcCleanQueries>,
653 pub loaded_from_disk: Option<RustcCleanQueries>,
654}
655
656#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanQueries {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
RustcCleanQueries {
entries: ::core::clone::Clone::clone(&self.entries),
span: ::core::clone::Clone::clone(&self.span),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcCleanQueries {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcCleanQueries entries span", &self.entries, &&self.span)
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RustcCleanQueries {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcCleanQueries {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.entries == other.entries && self.span == other.span
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcCleanQueries {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<ThinVec<Symbol>>;
let _: ::core::cmp::AssertParamIsEq<Span>;
}
}Eq)]
658#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcCleanQueries {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcCleanQueries {
entries: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcCleanQueries {
fn encode(&self, __encoder: &mut __E) {
let RustcCleanQueries {
entries: ref __binding_0, span: ref __binding_1 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcCleanQueries {
fn decode(__decoder: &mut __D) -> Self {
RustcCleanQueries {
entries: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcCleanQueries {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { entries, span } = self;
__p.word("RustcCleanQueries");
if true && !entries.should_render() && !span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if entries.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("entries");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
entries.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
659pub struct RustcCleanQueries {
660 pub entries: ThinVec<Symbol>,
661 pub span: Span,
662}
663
664#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcAutodiff {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
RustcAutodiff {
mode: ::core::clone::Clone::clone(&self.mode),
width: ::core::clone::Clone::clone(&self.width),
input_activity: ::core::clone::Clone::clone(&self.input_activity),
ret_activity: ::core::clone::Clone::clone(&self.ret_activity),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcAutodiff {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field4_finish(f,
"RustcAutodiff mode width input_activity ret_activity",
&self.mode, &self.width, &self.input_activity,
&&self.ret_activity)
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RustcAutodiff {
}
#[automatically_derived]impl ::core::cmp::PartialEq for RustcAutodiff {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.width == other.width && self.mode == other.mode &&
self.input_activity == other.input_activity &&
self.ret_activity == other.ret_activity
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcAutodiff {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<DiffMode>;
let _: ::core::cmp::AssertParamIsEq<u32>;
let _: ::core::cmp::AssertParamIsEq<ThinVec<DiffActivity>>;
let _: ::core::cmp::AssertParamIsEq<DiffActivity>;
}
}Eq)]
665#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcAutodiff {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcAutodiff {
mode: ref __binding_0,
width: ref __binding_1,
input_activity: ref __binding_2,
ret_activity: ref __binding_3 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcAutodiff {
fn encode(&self, __encoder: &mut __E) {
let RustcAutodiff {
mode: ref __binding_0,
width: ref __binding_1,
input_activity: ref __binding_2,
ret_activity: ref __binding_3 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcAutodiff {
fn decode(__decoder: &mut __D) -> Self {
RustcAutodiff {
mode: ::rustc_serialize::Decodable::decode(__decoder),
width: ::rustc_serialize::Decodable::decode(__decoder),
input_activity: ::rustc_serialize::Decodable::decode(__decoder),
ret_activity: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcAutodiff {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { mode, width, input_activity, ret_activity } = self;
__p.word("RustcAutodiff");
if true && !mode.should_render() && !width.should_render() &&
!input_activity.should_render() &&
!ret_activity.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if mode.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("mode");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
mode.print_attribute(__p);
if width.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("width");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
width.print_attribute(__p);
if input_activity.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("input_activity");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
input_activity.print_attribute(__p);
if ret_activity.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("ret_activity");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
ret_activity.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
666pub struct RustcAutodiff {
667 pub mode: DiffMode,
671 pub width: u32,
682 pub input_activity: ThinVec<DiffActivity>,
683 pub ret_activity: DiffActivity,
684}
685
686impl RustcAutodiff {
687 pub fn has_primal_ret(&self) -> bool {
688 #[allow(non_exhaustive_omitted_patterns)] match self.ret_activity {
DiffActivity::Active | DiffActivity::Dual => true,
_ => false,
}matches!(self.ret_activity, DiffActivity::Active | DiffActivity::Dual)
689 }
690}
691
692impl RustcAutodiff {
693 pub fn has_ret_activity(&self) -> bool {
694 self.ret_activity != DiffActivity::None
695 }
696 pub fn has_active_only_ret(&self) -> bool {
697 self.ret_activity == DiffActivity::ActiveOnly
698 }
699
700 pub fn error() -> Self {
701 RustcAutodiff {
702 mode: DiffMode::Error,
703 width: 0,
704 ret_activity: DiffActivity::None,
705 input_activity: ThinVec::new(),
706 }
707 }
708
709 pub fn source() -> Self {
710 RustcAutodiff {
711 mode: DiffMode::Source,
712 width: 0,
713 ret_activity: DiffActivity::None,
714 input_activity: ThinVec::new(),
715 }
716 }
717
718 pub fn is_active(&self) -> bool {
719 self.mode != DiffMode::Error
720 }
721
722 pub fn is_source(&self) -> bool {
723 self.mode == DiffMode::Source
724 }
725 pub fn apply_autodiff(&self) -> bool {
726 !#[allow(non_exhaustive_omitted_patterns)] match self.mode {
DiffMode::Error | DiffMode::Source => true,
_ => false,
}matches!(self.mode, DiffMode::Error | DiffMode::Source)
727 }
728
729 pub fn into_item(
730 self,
731 source: String,
732 target: String,
733 inputs: Vec<TypeTree>,
734 output: TypeTree,
735 ) -> AutoDiffItem {
736 AutoDiffItem { source, target, inputs, output, attrs: self }
737 }
738}
739
740#[derive(#[automatically_derived]impl ::core::clone::Clone for AutoDiffItem {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
AutoDiffItem {
source: ::core::clone::Clone::clone(&self.source),
target: ::core::clone::Clone::clone(&self.target),
attrs: ::core::clone::Clone::clone(&self.attrs),
inputs: ::core::clone::Clone::clone(&self.inputs),
output: ::core::clone::Clone::clone(&self.output),
}
}
}Clone, #[automatically_derived]impl ::core::cmp::Eq for AutoDiffItem {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<String>;
let _: ::core::cmp::AssertParamIsEq<RustcAutodiff>;
let _: ::core::cmp::AssertParamIsEq<Vec<TypeTree>>;
let _: ::core::cmp::AssertParamIsEq<TypeTree>;
}
}Eq, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
AutoDiffItem {
}
#[automatically_derived]impl ::core::cmp::PartialEq for AutoDiffItem {
#[inline]
fn eq(&self, other: &Self) -> bool {
self.source == other.source && self.target == other.target &&
self.attrs == other.attrs && self.inputs == other.inputs &&
self.output == other.output
}
}PartialEq, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for AutoDiffItem {
fn encode(&self, __encoder: &mut __E) {
let AutoDiffItem {
source: ref __binding_0,
target: ref __binding_1,
attrs: ref __binding_2,
inputs: ref __binding_3,
output: ref __binding_4 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_4,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for AutoDiffItem {
fn decode(__decoder: &mut __D) -> Self {
AutoDiffItem {
source: ::rustc_serialize::Decodable::decode(__decoder),
target: ::rustc_serialize::Decodable::decode(__decoder),
attrs: ::rustc_serialize::Decodable::decode(__decoder),
inputs: ::rustc_serialize::Decodable::decode(__decoder),
output: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, #[automatically_derived]impl ::core::fmt::Debug for AutoDiffItem {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field5_finish(f,
"AutoDiffItem source target attrs inputs output", &self.source,
&self.target, &self.attrs, &self.inputs, &&self.output)
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for AutoDiffItem
{
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
AutoDiffItem {
source: ref __binding_0,
target: ref __binding_1,
attrs: ref __binding_2,
inputs: ref __binding_3,
output: ref __binding_4 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
{ __binding_4.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash)]
742pub struct AutoDiffItem {
743 pub source: String,
745 pub target: String,
747 pub attrs: RustcAutodiff,
748 pub inputs: Vec<TypeTree>,
749 pub output: TypeTree,
750}
751
752impl fmt::Display for AutoDiffItem {
753 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
754 f.write_fmt(format_args!("Differentiating {0} -> {1}", self.source,
self.target))write!(f, "Differentiating {} -> {}", self.source, self.target)?;
755 f.write_fmt(format_args!(" with attributes: {0:?}", self.attrs))write!(f, " with attributes: {:?}", self.attrs)?;
756 f.write_fmt(format_args!(" with inputs: {0:?}", self.inputs))write!(f, " with inputs: {:?}", self.inputs)?;
757 f.write_fmt(format_args!(" with output: {0:?}", self.output))write!(f, " with output: {:?}", self.output)
758 }
759}
760
761#[derive(#[automatically_derived]impl ::core::marker::Copy for RustcAssertVarianceKind
{
}Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for RustcAssertVarianceKind {
}
#[automatically_derived]impl ::core::clone::Clone for RustcAssertVarianceKind
{
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcAssertVarianceKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::write_str(f,
match self {
RustcAssertVarianceKind::Covariant => "Covariant",
RustcAssertVarianceKind::Invariant => "Invariant",
RustcAssertVarianceKind::Contravariant => "Contravariant",
RustcAssertVarianceKind::Bivariant => "Bivariant",
})
}
}Debug, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
RustcAssertVarianceKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for
RustcAssertVarianceKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other)
}
}PartialEq, #[automatically_derived]impl ::core::cmp::Eq for RustcAssertVarianceKind { }Eq)]
762#[derive(const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
RustcAssertVarianceKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
RustcAssertVarianceKind::Covariant =>
0u8.stable_hash(__hcx, __hasher),
RustcAssertVarianceKind::Invariant =>
1u8.stable_hash(__hcx, __hasher),
RustcAssertVarianceKind::Contravariant =>
2u8.stable_hash(__hcx, __hasher),
RustcAssertVarianceKind::Bivariant =>
3u8.stable_hash(__hcx, __hasher),
}
match *self {
RustcAssertVarianceKind::Covariant => {}
RustcAssertVarianceKind::Invariant => {}
RustcAssertVarianceKind::Contravariant => {}
RustcAssertVarianceKind::Bivariant => {}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for RustcAssertVarianceKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
RustcAssertVarianceKind::Covariant => { 0usize }
RustcAssertVarianceKind::Invariant => { 1usize }
RustcAssertVarianceKind::Contravariant => { 2usize }
RustcAssertVarianceKind::Bivariant => { 3usize }
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for RustcAssertVarianceKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => { RustcAssertVarianceKind::Covariant }
1usize => { RustcAssertVarianceKind::Invariant }
2usize => { RustcAssertVarianceKind::Contravariant }
3usize => { RustcAssertVarianceKind::Bivariant }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcAssertVarianceKind`, expected 0..4, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for RustcAssertVarianceKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::Covariant => { __p.word("Covariant") }
Self::Invariant => { __p.word("Invariant") }
Self::Contravariant => { __p.word("Contravariant") }
Self::Bivariant => { __p.word("Bivariant") }
}
}
}
};PrintAttribute)]
763pub enum RustcAssertVarianceKind {
764 Covariant,
765 Invariant,
766 Contravariant,
767 Bivariant,
768}
769
770#[derive(#[automatically_derived]impl ::core::clone::Clone for UnstableRemovedFeature {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
UnstableRemovedFeature {
feature: ::core::clone::Clone::clone(&self.feature),
reason: ::core::clone::Clone::clone(&self.reason),
link: ::core::clone::Clone::clone(&self.link),
since: ::core::clone::Clone::clone(&self.since),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for UnstableRemovedFeature {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
::core::fmt::Formatter::debug_struct_field4_finish(f,
"UnstableRemovedFeature feature reason link since", &self.feature,
&self.reason, &self.link, &&self.since)
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
UnstableRemovedFeature {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
UnstableRemovedFeature {
feature: ref __binding_0,
reason: ref __binding_1,
link: ref __binding_2,
since: ref __binding_3 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for UnstableRemovedFeature {
fn encode(&self, __encoder: &mut __E) {
let UnstableRemovedFeature {
feature: ref __binding_0,
reason: ref __binding_1,
link: ref __binding_2,
since: ref __binding_3 } = *self;
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for UnstableRemovedFeature {
fn decode(__decoder: &mut __D) -> Self {
UnstableRemovedFeature {
feature: ::rustc_serialize::Decodable::decode(__decoder),
reason: ::rustc_serialize::Decodable::decode(__decoder),
link: ::rustc_serialize::Decodable::decode(__decoder),
since: ::rustc_serialize::Decodable::decode(__decoder),
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for UnstableRemovedFeature {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
let Self { feature, reason, link, since } = self;
__p.word("UnstableRemovedFeature");
if true && !feature.should_render() && !reason.should_render()
&& !link.should_render() && !since.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if feature.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("feature");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
feature.print_attribute(__p);
if reason.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reason");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reason.print_attribute(__p);
if link.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("link");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
link.print_attribute(__p);
if since.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("since");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
since.print_attribute(__p);
__p.word("}");
}
}
};PrintAttribute)]
771pub struct UnstableRemovedFeature {
772 pub feature: Symbol,
773 pub reason: Symbol,
774 pub link: Symbol,
775 pub since: RustcVersion,
776}
777
778#[derive(#[automatically_derived]impl ::core::clone::Clone for AttributeKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
match self {
Self::AllowInternalUnsafe(__self_0) =>
AttributeKind::AllowInternalUnsafe(::core::clone::Clone::clone(__self_0)),
Self::AllowInternalUnstable(__self_0, __self_1) =>
AttributeKind::AllowInternalUnstable(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::AlwaysGca => AttributeKind::AlwaysGca,
Self::AutomaticallyDerived => AttributeKind::AutomaticallyDerived,
Self::CfgAttrTrace(__self_0) =>
AttributeKind::CfgAttrTrace(::core::clone::Clone::clone(__self_0)),
Self::CfgTrace(__self_0) =>
AttributeKind::CfgTrace(::core::clone::Clone::clone(__self_0)),
Self::CfiEncoding { encoding: __self_0 } =>
AttributeKind::CfiEncoding {
encoding: ::core::clone::Clone::clone(__self_0),
},
Self::Cold => AttributeKind::Cold,
Self::CollapseDebugInfo(__self_0) =>
AttributeKind::CollapseDebugInfo(::core::clone::Clone::clone(__self_0)),
Self::CompilerBuiltins => AttributeKind::CompilerBuiltins,
Self::ConstContinue(__self_0) =>
AttributeKind::ConstContinue(::core::clone::Clone::clone(__self_0)),
Self::Coroutine => AttributeKind::Coroutine,
Self::Coverage(__self_0) =>
AttributeKind::Coverage(::core::clone::Clone::clone(__self_0)),
Self::CrateName {
name: __self_0, name_span: __self_1, attr_span: __self_2 } =>
AttributeKind::CrateName {
name: ::core::clone::Clone::clone(__self_0),
name_span: ::core::clone::Clone::clone(__self_1),
attr_span: ::core::clone::Clone::clone(__self_2),
},
Self::CrateType(__self_0) =>
AttributeKind::CrateType(::core::clone::Clone::clone(__self_0)),
Self::CustomMir(__self_0, __self_1) =>
AttributeKind::CustomMir(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::DebuggerVisualizer(__self_0) =>
AttributeKind::DebuggerVisualizer(::core::clone::Clone::clone(__self_0)),
Self::DefaultLibAllocator => AttributeKind::DefaultLibAllocator,
Self::Deprecated {
deprecation: __self_0, span: __self_1, is_inner: __self_2 } =>
AttributeKind::Deprecated {
deprecation: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
is_inner: ::core::clone::Clone::clone(__self_2),
},
Self::DoNotRecommend => AttributeKind::DoNotRecommend,
Self::Doc(__self_0) =>
AttributeKind::Doc(::core::clone::Clone::clone(__self_0)),
Self::DocComment {
style: __self_0,
kind: __self_1,
span: __self_2,
comment: __self_3 } =>
AttributeKind::DocComment {
style: ::core::clone::Clone::clone(__self_0),
kind: ::core::clone::Clone::clone(__self_1),
span: ::core::clone::Clone::clone(__self_2),
comment: ::core::clone::Clone::clone(__self_3),
},
Self::EiiDeclaration(__self_0) =>
AttributeKind::EiiDeclaration(::core::clone::Clone::clone(__self_0)),
Self::EiiImpl(__self_0) =>
AttributeKind::EiiImpl(::core::clone::Clone::clone(__self_0)),
Self::ExportName { name: __self_0, span: __self_1 } =>
AttributeKind::ExportName {
name: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::ExportStable => AttributeKind::ExportStable,
Self::Feature(__self_0, __self_1) =>
AttributeKind::Feature(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::FfiConst => AttributeKind::FfiConst,
Self::FfiPure(__self_0) =>
AttributeKind::FfiPure(::core::clone::Clone::clone(__self_0)),
Self::Fundamental => AttributeKind::Fundamental,
Self::Ignore { span: __self_0, reason: __self_1 } =>
AttributeKind::Ignore {
span: ::core::clone::Clone::clone(__self_0),
reason: ::core::clone::Clone::clone(__self_1),
},
Self::Inline(__self_0, __self_1) =>
AttributeKind::Inline(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::InstructionSet(__self_0) =>
AttributeKind::InstructionSet(::core::clone::Clone::clone(__self_0)),
Self::InstrumentFn(__self_0) =>
AttributeKind::InstrumentFn(::core::clone::Clone::clone(__self_0)),
Self::Lang(__self_0) =>
AttributeKind::Lang(::core::clone::Clone::clone(__self_0)),
Self::Link(__self_0, __self_1) =>
AttributeKind::Link(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::LinkName { name: __self_0, span: __self_1 } =>
AttributeKind::LinkName {
name: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::LinkOrdinal { ordinal: __self_0, span: __self_1 } =>
AttributeKind::LinkOrdinal {
ordinal: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::LinkSection { name: __self_0 } =>
AttributeKind::LinkSection {
name: ::core::clone::Clone::clone(__self_0),
},
Self::Linkage(__self_0, __self_1) =>
AttributeKind::Linkage(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::LintAsPtr => AttributeKind::LintAsPtr,
Self::LintCheck(__self_0) =>
AttributeKind::LintCheck(::core::clone::Clone::clone(__self_0)),
Self::LintNeverReturnsNullPtr =>
AttributeKind::LintNeverReturnsNullPtr,
Self::LintShouldNotBeCalledOnConstItems =>
AttributeKind::LintShouldNotBeCalledOnConstItems,
Self::LoopMatch(__self_0) =>
AttributeKind::LoopMatch(::core::clone::Clone::clone(__self_0)),
Self::MacroEscape => AttributeKind::MacroEscape,
Self::MacroExport { span: __self_0, local_inner_macros: __self_1 }
=>
AttributeKind::MacroExport {
span: ::core::clone::Clone::clone(__self_0),
local_inner_macros: ::core::clone::Clone::clone(__self_1),
},
Self::MacroUse { span: __self_0, arguments: __self_1 } =>
AttributeKind::MacroUse {
span: ::core::clone::Clone::clone(__self_0),
arguments: ::core::clone::Clone::clone(__self_1),
},
Self::Marker => AttributeKind::Marker,
Self::MayDangle(__self_0) =>
AttributeKind::MayDangle(::core::clone::Clone::clone(__self_0)),
Self::MoveSizeLimit { limit: __self_0 } =>
AttributeKind::MoveSizeLimit {
limit: ::core::clone::Clone::clone(__self_0),
},
Self::MustNotSuspend { reason: __self_0 } =>
AttributeKind::MustNotSuspend {
reason: ::core::clone::Clone::clone(__self_0),
},
Self::MustUse { span: __self_0, reason: __self_1 } =>
AttributeKind::MustUse {
span: ::core::clone::Clone::clone(__self_0),
reason: ::core::clone::Clone::clone(__self_1),
},
Self::Naked(__self_0) =>
AttributeKind::Naked(::core::clone::Clone::clone(__self_0)),
Self::NeedsAllocator => AttributeKind::NeedsAllocator,
Self::NeedsPanicRuntime => AttributeKind::NeedsPanicRuntime,
Self::NoBuiltins => AttributeKind::NoBuiltins,
Self::NoCore => AttributeKind::NoCore,
Self::NoImplicitPrelude => AttributeKind::NoImplicitPrelude,
Self::NoLink => AttributeKind::NoLink,
Self::NoMain => AttributeKind::NoMain,
Self::NoMangle(__self_0) =>
AttributeKind::NoMangle(::core::clone::Clone::clone(__self_0)),
Self::NoStd => AttributeKind::NoStd,
Self::NonExhaustive(__self_0) =>
AttributeKind::NonExhaustive(::core::clone::Clone::clone(__self_0)),
Self::OnConst { span: __self_0, directive: __self_1 } =>
AttributeKind::OnConst {
span: ::core::clone::Clone::clone(__self_0),
directive: ::core::clone::Clone::clone(__self_1),
},
Self::OnMove { directive: __self_0 } =>
AttributeKind::OnMove {
directive: ::core::clone::Clone::clone(__self_0),
},
Self::OnTypeError { span: __self_0, directive: __self_1 } =>
AttributeKind::OnTypeError {
span: ::core::clone::Clone::clone(__self_0),
directive: ::core::clone::Clone::clone(__self_1),
},
Self::OnUnimplemented { directive: __self_0 } =>
AttributeKind::OnUnimplemented {
directive: ::core::clone::Clone::clone(__self_0),
},
Self::OnUnknown { directive: __self_0 } =>
AttributeKind::OnUnknown {
directive: ::core::clone::Clone::clone(__self_0),
},
Self::OnUnmatchedArgs { directive: __self_0 } =>
AttributeKind::OnUnmatchedArgs {
directive: ::core::clone::Clone::clone(__self_0),
},
Self::Opaque => AttributeKind::Opaque,
Self::Optimize(__self_0, __self_1) =>
AttributeKind::Optimize(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::PanicRuntime => AttributeKind::PanicRuntime,
Self::PatchableFunctionEntry {
prefix: __self_0, entry: __self_1, section: __self_2 } =>
AttributeKind::PatchableFunctionEntry {
prefix: ::core::clone::Clone::clone(__self_0),
entry: ::core::clone::Clone::clone(__self_1),
section: ::core::clone::Clone::clone(__self_2),
},
Self::Path(__self_0, __self_1) =>
AttributeKind::Path(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::PatternComplexityLimit { limit: __self_0 } =>
AttributeKind::PatternComplexityLimit {
limit: ::core::clone::Clone::clone(__self_0),
},
Self::PinV2(__self_0) =>
AttributeKind::PinV2(::core::clone::Clone::clone(__self_0)),
Self::PreludeImport => AttributeKind::PreludeImport,
Self::ProcMacro => AttributeKind::ProcMacro,
Self::ProcMacroAttribute => AttributeKind::ProcMacroAttribute,
Self::ProcMacroDerive {
trait_name: __self_0, helper_attrs: __self_1 } =>
AttributeKind::ProcMacroDerive {
trait_name: ::core::clone::Clone::clone(__self_0),
helper_attrs: ::core::clone::Clone::clone(__self_1),
},
Self::ProfilerRuntime => AttributeKind::ProfilerRuntime,
Self::RecursionLimit { limit: __self_0 } =>
AttributeKind::RecursionLimit {
limit: ::core::clone::Clone::clone(__self_0),
},
Self::ReexportTestHarnessMain(__self_0) =>
AttributeKind::ReexportTestHarnessMain(::core::clone::Clone::clone(__self_0)),
Self::RegisterTool { attr_tools: __self_0, lint_tools: __self_1 }
=>
AttributeKind::RegisterTool {
attr_tools: ::core::clone::Clone::clone(__self_0),
lint_tools: ::core::clone::Clone::clone(__self_1),
},
Self::Repr { reprs: __self_0, first_span: __self_1 } =>
AttributeKind::Repr {
reprs: ::core::clone::Clone::clone(__self_0),
first_span: ::core::clone::Clone::clone(__self_1),
},
Self::RustcAbi { attr_span: __self_0, kind: __self_1 } =>
AttributeKind::RustcAbi {
attr_span: ::core::clone::Clone::clone(__self_0),
kind: ::core::clone::Clone::clone(__self_1),
},
Self::RustcAlign { align: __self_0, span: __self_1 } =>
AttributeKind::RustcAlign {
align: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::RustcAllocator => AttributeKind::RustcAllocator,
Self::RustcAllocatorZeroed => AttributeKind::RustcAllocatorZeroed,
Self::RustcAllocatorZeroedVariant { name: __self_0 } =>
AttributeKind::RustcAllocatorZeroedVariant {
name: ::core::clone::Clone::clone(__self_0),
},
Self::RustcAllowConstFnUnstable(__self_0, __self_1) =>
AttributeKind::RustcAllowConstFnUnstable(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::RustcAllowIncoherentImpl(__self_0) =>
AttributeKind::RustcAllowIncoherentImpl(::core::clone::Clone::clone(__self_0)),
Self::RustcAllowLifetimeDependentSpecialization =>
AttributeKind::RustcAllowLifetimeDependentSpecialization,
Self::RustcAssertVariance { span: __self_0, kind: __self_1 } =>
AttributeKind::RustcAssertVariance {
span: ::core::clone::Clone::clone(__self_0),
kind: ::core::clone::Clone::clone(__self_1),
},
Self::RustcAutodiff(__self_0) =>
AttributeKind::RustcAutodiff(::core::clone::Clone::clone(__self_0)),
Self::RustcBodyStability { stability: __self_0, span: __self_1 }
=>
AttributeKind::RustcBodyStability {
stability: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::RustcBuiltinMacro {
builtin_name: __self_0, helper_attrs: __self_1 } =>
AttributeKind::RustcBuiltinMacro {
builtin_name: ::core::clone::Clone::clone(__self_0),
helper_attrs: ::core::clone::Clone::clone(__self_1),
},
Self::RustcCanonicalSymbol => AttributeKind::RustcCanonicalSymbol,
Self::RustcCaptureAnalysis => AttributeKind::RustcCaptureAnalysis,
Self::RustcCguTestAttr(__self_0) =>
AttributeKind::RustcCguTestAttr(::core::clone::Clone::clone(__self_0)),
Self::RustcClean(__self_0) =>
AttributeKind::RustcClean(::core::clone::Clone::clone(__self_0)),
Self::RustcCoherenceIsCore => AttributeKind::RustcCoherenceIsCore,
Self::RustcCoinductive => AttributeKind::RustcCoinductive,
Self::RustcComptime(__self_0) =>
AttributeKind::RustcComptime(::core::clone::Clone::clone(__self_0)),
Self::RustcConfusables { confusables: __self_0 } =>
AttributeKind::RustcConfusables {
confusables: ::core::clone::Clone::clone(__self_0),
},
Self::RustcConstStability { stability: __self_0, span: __self_1 }
=>
AttributeKind::RustcConstStability {
stability: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::RustcConstStableIndirect =>
AttributeKind::RustcConstStableIndirect,
Self::RustcConversionSuggestion =>
AttributeKind::RustcConversionSuggestion,
Self::RustcDeallocator => AttributeKind::RustcDeallocator,
Self::RustcDelayedBugFromInsideQuery =>
AttributeKind::RustcDelayedBugFromInsideQuery,
Self::RustcDenyExplicitImpl =>
AttributeKind::RustcDenyExplicitImpl,
Self::RustcDeprecatedSafe2024 { suggestion: __self_0 } =>
AttributeKind::RustcDeprecatedSafe2024 {
suggestion: ::core::clone::Clone::clone(__self_0),
},
Self::RustcDiagnosticItem(__self_0) =>
AttributeKind::RustcDiagnosticItem(::core::clone::Clone::clone(__self_0)),
Self::RustcDoNotConstCheck => AttributeKind::RustcDoNotConstCheck,
Self::RustcDocPrimitive(__self_0, __self_1) =>
AttributeKind::RustcDocPrimitive(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::RustcDummy => AttributeKind::RustcDummy,
Self::RustcDumpClauses => AttributeKind::RustcDumpClauses,
Self::RustcDumpDefParents => AttributeKind::RustcDumpDefParents,
Self::RustcDumpDefPath(__self_0) =>
AttributeKind::RustcDumpDefPath(::core::clone::Clone::clone(__self_0)),
Self::RustcDumpGenerics => AttributeKind::RustcDumpGenerics,
Self::RustcDumpHiddenTypeOfOpaques =>
AttributeKind::RustcDumpHiddenTypeOfOpaques,
Self::RustcDumpInferredOutlives =>
AttributeKind::RustcDumpInferredOutlives,
Self::RustcDumpItemBounds => AttributeKind::RustcDumpItemBounds,
Self::RustcDumpLayout(__self_0) =>
AttributeKind::RustcDumpLayout(::core::clone::Clone::clone(__self_0)),
Self::RustcDumpObjectLifetimeDefaults =>
AttributeKind::RustcDumpObjectLifetimeDefaults,
Self::RustcDumpSymbolName(__self_0) =>
AttributeKind::RustcDumpSymbolName(::core::clone::Clone::clone(__self_0)),
Self::RustcDumpUserArgs => AttributeKind::RustcDumpUserArgs,
Self::RustcDumpVariances => AttributeKind::RustcDumpVariances,
Self::RustcDumpVariancesOfOpaques =>
AttributeKind::RustcDumpVariancesOfOpaques,
Self::RustcDumpVtable(__self_0) =>
AttributeKind::RustcDumpVtable(::core::clone::Clone::clone(__self_0)),
Self::RustcDynIncompatibleTrait(__self_0) =>
AttributeKind::RustcDynIncompatibleTrait(::core::clone::Clone::clone(__self_0)),
Self::RustcEffectiveVisibility =>
AttributeKind::RustcEffectiveVisibility,
Self::RustcEiiForeignItem => AttributeKind::RustcEiiForeignItem,
Self::RustcEvaluateWhereClauses =>
AttributeKind::RustcEvaluateWhereClauses,
Self::RustcHasIncoherentInherentImpls =>
AttributeKind::RustcHasIncoherentInherentImpls,
Self::RustcIfThisChanged(__self_0, __self_1) =>
AttributeKind::RustcIfThisChanged(::core::clone::Clone::clone(__self_0),
::core::clone::Clone::clone(__self_1)),
Self::RustcInheritOverflowChecks =>
AttributeKind::RustcInheritOverflowChecks,
Self::RustcInsignificantDtor =>
AttributeKind::RustcInsignificantDtor,
Self::RustcIntrinsic { llvm: __self_0 } =>
AttributeKind::RustcIntrinsic {
llvm: ::core::clone::Clone::clone(__self_0),
},
Self::RustcIntrinsicConstStableIndirect =>
AttributeKind::RustcIntrinsicConstStableIndirect,
Self::RustcLegacyConstGenerics {
fn_indexes: __self_0, attr_span: __self_1 } =>
AttributeKind::RustcLegacyConstGenerics {
fn_indexes: ::core::clone::Clone::clone(__self_0),
attr_span: ::core::clone::Clone::clone(__self_1),
},
Self::RustcLintOptDenyFieldAccess { lint_message: __self_0 } =>
AttributeKind::RustcLintOptDenyFieldAccess {
lint_message: ::core::clone::Clone::clone(__self_0),
},
Self::RustcLintOptTy => AttributeKind::RustcLintOptTy,
Self::RustcLintQueryInstability =>
AttributeKind::RustcLintQueryInstability,
Self::RustcLintUntrackedQueryInformation =>
AttributeKind::RustcLintUntrackedQueryInformation,
Self::RustcMacroTransparency(__self_0) =>
AttributeKind::RustcMacroTransparency(::core::clone::Clone::clone(__self_0)),
Self::RustcMain => AttributeKind::RustcMain,
Self::RustcMir(__self_0) =>
AttributeKind::RustcMir(::core::clone::Clone::clone(__self_0)),
Self::RustcMustImplementOneOf {
attr_span: __self_0, fn_names: __self_1 } =>
AttributeKind::RustcMustImplementOneOf {
attr_span: ::core::clone::Clone::clone(__self_0),
fn_names: ::core::clone::Clone::clone(__self_1),
},
Self::RustcMustMatchExhaustively(__self_0) =>
AttributeKind::RustcMustMatchExhaustively(::core::clone::Clone::clone(__self_0)),
Self::RustcNoImplicitAutorefs =>
AttributeKind::RustcNoImplicitAutorefs,
Self::RustcNoImplicitBounds =>
AttributeKind::RustcNoImplicitBounds,
Self::RustcNoMirInline => AttributeKind::RustcNoMirInline,
Self::RustcNoWritable => AttributeKind::RustcNoWritable,
Self::RustcNonConstTraitMethod =>
AttributeKind::RustcNonConstTraitMethod,
Self::RustcNonnullOptimizationGuaranteed =>
AttributeKind::RustcNonnullOptimizationGuaranteed,
Self::RustcNounwind => AttributeKind::RustcNounwind,
Self::RustcObjcClass { classname: __self_0 } =>
AttributeKind::RustcObjcClass {
classname: ::core::clone::Clone::clone(__self_0),
},
Self::RustcObjcSelector { methname: __self_0 } =>
AttributeKind::RustcObjcSelector {
methname: ::core::clone::Clone::clone(__self_0),
},
Self::RustcOffloadKernel => AttributeKind::RustcOffloadKernel,
Self::RustcPanicsWhenZero => AttributeKind::RustcPanicsWhenZero,
Self::RustcParenSugar => AttributeKind::RustcParenSugar,
Self::RustcPassByValue => AttributeKind::RustcPassByValue,
Self::RustcPassIndirectlyInNonRusticAbis(__self_0) =>
AttributeKind::RustcPassIndirectlyInNonRusticAbis(::core::clone::Clone::clone(__self_0)),
Self::RustcPreserveUbChecks =>
AttributeKind::RustcPreserveUbChecks,
Self::RustcProcMacroDecls => AttributeKind::RustcProcMacroDecls,
Self::RustcPubTransparent(__self_0) =>
AttributeKind::RustcPubTransparent(::core::clone::Clone::clone(__self_0)),
Self::RustcReallocator => AttributeKind::RustcReallocator,
Self::RustcRegions => AttributeKind::RustcRegions,
Self::RustcScalableVector { element_count: __self_0 } =>
AttributeKind::RustcScalableVector {
element_count: ::core::clone::Clone::clone(__self_0),
},
Self::RustcShowSpans(__self_0) =>
AttributeKind::RustcShowSpans(::core::clone::Clone::clone(__self_0)),
Self::RustcSimdMonomorphizeLaneLimit(__self_0) =>
AttributeKind::RustcSimdMonomorphizeLaneLimit(::core::clone::Clone::clone(__self_0)),
Self::RustcSkipDuringMethodDispatch {
array: __self_0, boxed_slice: __self_1 } =>
AttributeKind::RustcSkipDuringMethodDispatch {
array: ::core::clone::Clone::clone(__self_0),
boxed_slice: ::core::clone::Clone::clone(__self_1),
},
Self::RustcSpecializationTrait =>
AttributeKind::RustcSpecializationTrait,
Self::RustcStdInternalSymbol =>
AttributeKind::RustcStdInternalSymbol,
Self::RustcStrictCoherence(__self_0) =>
AttributeKind::RustcStrictCoherence(::core::clone::Clone::clone(__self_0)),
Self::RustcTestEntrypointMarker =>
AttributeKind::RustcTestEntrypointMarker,
Self::RustcTestMarker(__self_0) =>
AttributeKind::RustcTestMarker(::core::clone::Clone::clone(__self_0)),
Self::RustcThenThisWouldNeed(__self_0) =>
AttributeKind::RustcThenThisWouldNeed(::core::clone::Clone::clone(__self_0)),
Self::RustcTrivialFieldReads(__self_0) =>
AttributeKind::RustcTrivialFieldReads(::core::clone::Clone::clone(__self_0)),
Self::Sanitize {
on_set: __self_0,
off_set: __self_1,
rtsan: __self_2,
span: __self_3 } =>
AttributeKind::Sanitize {
on_set: ::core::clone::Clone::clone(__self_0),
off_set: ::core::clone::Clone::clone(__self_1),
rtsan: ::core::clone::Clone::clone(__self_2),
span: ::core::clone::Clone::clone(__self_3),
},
Self::ShouldPanic { reason: __self_0 } =>
AttributeKind::ShouldPanic {
reason: ::core::clone::Clone::clone(__self_0),
},
Self::Splat(__self_0) =>
AttributeKind::Splat(::core::clone::Clone::clone(__self_0)),
Self::Stability { stability: __self_0, span: __self_1 } =>
AttributeKind::Stability {
stability: ::core::clone::Clone::clone(__self_0),
span: ::core::clone::Clone::clone(__self_1),
},
Self::TargetFeature {
features: __self_0, attr_span: __self_1, was_forced: __self_2
} =>
AttributeKind::TargetFeature {
features: ::core::clone::Clone::clone(__self_0),
attr_span: ::core::clone::Clone::clone(__self_1),
was_forced: ::core::clone::Clone::clone(__self_2),
},
Self::TestRunner(__self_0) =>
AttributeKind::TestRunner(::core::clone::Clone::clone(__self_0)),
Self::ThreadLocal => AttributeKind::ThreadLocal,
Self::TrackCaller(__self_0) =>
AttributeKind::TrackCaller(::core::clone::Clone::clone(__self_0)),
Self::TypeLengthLimit { limit: __self_0 } =>
AttributeKind::TypeLengthLimit {
limit: ::core::clone::Clone::clone(__self_0),
},
Self::UncheckedTypeAlias => AttributeKind::UncheckedTypeAlias,
Self::Unroll(__self_0) =>
AttributeKind::Unroll(::core::clone::Clone::clone(__self_0)),
Self::UnstableFeatureBound(__self_0) =>
AttributeKind::UnstableFeatureBound(::core::clone::Clone::clone(__self_0)),
Self::UnstableRemoved(__self_0) =>
AttributeKind::UnstableRemoved(::core::clone::Clone::clone(__self_0)),
Self::Used { used_by: __self_0 } =>
AttributeKind::Used {
used_by: ::core::clone::Clone::clone(__self_0),
},
Self::WindowsSubsystem(__self_0) =>
AttributeKind::WindowsSubsystem(::core::clone::Clone::clone(__self_0)),
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for AttributeKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::AllowInternalUnsafe(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"AllowInternalUnsafe", &__self_0),
Self::AllowInternalUnstable(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"AllowInternalUnstable", __self_0, &__self_1),
Self::AlwaysGca =>
::core::fmt::Formatter::write_str(f, "AlwaysGca"),
Self::AutomaticallyDerived =>
::core::fmt::Formatter::write_str(f, "AutomaticallyDerived"),
Self::CfgAttrTrace(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"CfgAttrTrace", &__self_0),
Self::CfgTrace(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"CfgTrace", &__self_0),
Self::CfiEncoding { encoding: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"CfiEncoding encoding", &__self_0),
Self::Cold => ::core::fmt::Formatter::write_str(f, "Cold"),
Self::CollapseDebugInfo(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"CollapseDebugInfo", &__self_0),
Self::CompilerBuiltins =>
::core::fmt::Formatter::write_str(f, "CompilerBuiltins"),
Self::ConstContinue(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ConstContinue", &__self_0),
Self::Coroutine =>
::core::fmt::Formatter::write_str(f, "Coroutine"),
Self::Coverage(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Coverage", &__self_0),
Self::CrateName {
name: __self_0, name_span: __self_1, attr_span: __self_2 } =>
::core::fmt::Formatter::debug_struct_field3_finish(f,
"CrateName name name_span attr_span", __self_0, __self_1,
&__self_2),
Self::CrateType(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"CrateType", &__self_0),
Self::CustomMir(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"CustomMir", __self_0, &__self_1),
Self::DebuggerVisualizer(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"DebuggerVisualizer", &__self_0),
Self::DefaultLibAllocator =>
::core::fmt::Formatter::write_str(f, "DefaultLibAllocator"),
Self::Deprecated {
deprecation: __self_0, span: __self_1, is_inner: __self_2 } =>
::core::fmt::Formatter::debug_struct_field3_finish(f,
"Deprecated deprecation span is_inner", __self_0, __self_1,
&__self_2),
Self::DoNotRecommend =>
::core::fmt::Formatter::write_str(f, "DoNotRecommend"),
Self::Doc(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Doc",
&__self_0),
Self::DocComment {
style: __self_0,
kind: __self_1,
span: __self_2,
comment: __self_3 } =>
::core::fmt::Formatter::debug_struct_field4_finish(f,
"DocComment style kind span comment", __self_0, __self_1,
__self_2, &__self_3),
Self::EiiDeclaration(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"EiiDeclaration", &__self_0),
Self::EiiImpl(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"EiiImpl", &__self_0),
Self::ExportName { name: __self_0, span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"ExportName name span", __self_0, &__self_1),
Self::ExportStable =>
::core::fmt::Formatter::write_str(f, "ExportStable"),
Self::Feature(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Feature", __self_0, &__self_1),
Self::FfiConst =>
::core::fmt::Formatter::write_str(f, "FfiConst"),
Self::FfiPure(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"FfiPure", &__self_0),
Self::Fundamental =>
::core::fmt::Formatter::write_str(f, "Fundamental"),
Self::Ignore { span: __self_0, reason: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Ignore span reason", __self_0, &__self_1),
Self::Inline(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Inline", __self_0, &__self_1),
Self::InstructionSet(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"InstructionSet", &__self_0),
Self::InstrumentFn(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"InstrumentFn", &__self_0),
Self::Lang(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Lang",
&__self_0),
Self::Link(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f, "Link",
__self_0, &__self_1),
Self::LinkName { name: __self_0, span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"LinkName name span", __self_0, &__self_1),
Self::LinkOrdinal { ordinal: __self_0, span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"LinkOrdinal ordinal span", __self_0, &__self_1),
Self::LinkSection { name: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"LinkSection name", &__self_0),
Self::Linkage(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Linkage", __self_0, &__self_1),
Self::LintAsPtr =>
::core::fmt::Formatter::write_str(f, "LintAsPtr"),
Self::LintCheck(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"LintCheck", &__self_0),
Self::LintNeverReturnsNullPtr =>
::core::fmt::Formatter::write_str(f,
"LintNeverReturnsNullPtr"),
Self::LintShouldNotBeCalledOnConstItems =>
::core::fmt::Formatter::write_str(f,
"LintShouldNotBeCalledOnConstItems"),
Self::LoopMatch(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"LoopMatch", &__self_0),
Self::MacroEscape =>
::core::fmt::Formatter::write_str(f, "MacroEscape"),
Self::MacroExport { span: __self_0, local_inner_macros: __self_1 }
=>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"MacroExport span local_inner_macros", __self_0, &__self_1),
Self::MacroUse { span: __self_0, arguments: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"MacroUse span arguments", __self_0, &__self_1),
Self::Marker => ::core::fmt::Formatter::write_str(f, "Marker"),
Self::MayDangle(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"MayDangle", &__self_0),
Self::MoveSizeLimit { limit: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"MoveSizeLimit limit", &__self_0),
Self::MustNotSuspend { reason: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"MustNotSuspend reason", &__self_0),
Self::MustUse { span: __self_0, reason: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"MustUse span reason", __self_0, &__self_1),
Self::Naked(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Naked",
&__self_0),
Self::NeedsAllocator =>
::core::fmt::Formatter::write_str(f, "NeedsAllocator"),
Self::NeedsPanicRuntime =>
::core::fmt::Formatter::write_str(f, "NeedsPanicRuntime"),
Self::NoBuiltins =>
::core::fmt::Formatter::write_str(f, "NoBuiltins"),
Self::NoCore => ::core::fmt::Formatter::write_str(f, "NoCore"),
Self::NoImplicitPrelude =>
::core::fmt::Formatter::write_str(f, "NoImplicitPrelude"),
Self::NoLink => ::core::fmt::Formatter::write_str(f, "NoLink"),
Self::NoMain => ::core::fmt::Formatter::write_str(f, "NoMain"),
Self::NoMangle(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"NoMangle", &__self_0),
Self::NoStd => ::core::fmt::Formatter::write_str(f, "NoStd"),
Self::NonExhaustive(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"NonExhaustive", &__self_0),
Self::OnConst { span: __self_0, directive: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"OnConst span directive", __self_0, &__self_1),
Self::OnMove { directive: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"OnMove directive", &__self_0),
Self::OnTypeError { span: __self_0, directive: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"OnTypeError span directive", __self_0, &__self_1),
Self::OnUnimplemented { directive: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"OnUnimplemented directive", &__self_0),
Self::OnUnknown { directive: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"OnUnknown directive", &__self_0),
Self::OnUnmatchedArgs { directive: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"OnUnmatchedArgs directive", &__self_0),
Self::Opaque => ::core::fmt::Formatter::write_str(f, "Opaque"),
Self::Optimize(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Optimize", __self_0, &__self_1),
Self::PanicRuntime =>
::core::fmt::Formatter::write_str(f, "PanicRuntime"),
Self::PatchableFunctionEntry {
prefix: __self_0, entry: __self_1, section: __self_2 } =>
::core::fmt::Formatter::debug_struct_field3_finish(f,
"PatchableFunctionEntry prefix entry section", __self_0,
__self_1, &__self_2),
Self::Path(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f, "Path",
__self_0, &__self_1),
Self::PatternComplexityLimit { limit: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"PatternComplexityLimit limit", &__self_0),
Self::PinV2(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "PinV2",
&__self_0),
Self::PreludeImport =>
::core::fmt::Formatter::write_str(f, "PreludeImport"),
Self::ProcMacro =>
::core::fmt::Formatter::write_str(f, "ProcMacro"),
Self::ProcMacroAttribute =>
::core::fmt::Formatter::write_str(f, "ProcMacroAttribute"),
Self::ProcMacroDerive {
trait_name: __self_0, helper_attrs: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"ProcMacroDerive trait_name helper_attrs", __self_0,
&__self_1),
Self::ProfilerRuntime =>
::core::fmt::Formatter::write_str(f, "ProfilerRuntime"),
Self::RecursionLimit { limit: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RecursionLimit limit", &__self_0),
Self::ReexportTestHarnessMain(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ReexportTestHarnessMain", &__self_0),
Self::RegisterTool { attr_tools: __self_0, lint_tools: __self_1 }
=>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RegisterTool attr_tools lint_tools", __self_0, &__self_1),
Self::Repr { reprs: __self_0, first_span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Repr reprs first_span", __self_0, &__self_1),
Self::RustcAbi { attr_span: __self_0, kind: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcAbi attr_span kind", __self_0, &__self_1),
Self::RustcAlign { align: __self_0, span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcAlign align span", __self_0, &__self_1),
Self::RustcAllocator =>
::core::fmt::Formatter::write_str(f, "RustcAllocator"),
Self::RustcAllocatorZeroed =>
::core::fmt::Formatter::write_str(f, "RustcAllocatorZeroed"),
Self::RustcAllocatorZeroedVariant { name: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcAllocatorZeroedVariant name", &__self_0),
Self::RustcAllowConstFnUnstable(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcAllowConstFnUnstable", __self_0, &__self_1),
Self::RustcAllowIncoherentImpl(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcAllowIncoherentImpl", &__self_0),
Self::RustcAllowLifetimeDependentSpecialization =>
::core::fmt::Formatter::write_str(f,
"RustcAllowLifetimeDependentSpecialization"),
Self::RustcAssertVariance { span: __self_0, kind: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcAssertVariance span kind", __self_0, &__self_1),
Self::RustcAutodiff(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcAutodiff", &__self_0),
Self::RustcBodyStability { stability: __self_0, span: __self_1 }
=>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcBodyStability stability span", __self_0, &__self_1),
Self::RustcBuiltinMacro {
builtin_name: __self_0, helper_attrs: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcBuiltinMacro builtin_name helper_attrs", __self_0,
&__self_1),
Self::RustcCanonicalSymbol =>
::core::fmt::Formatter::write_str(f, "RustcCanonicalSymbol"),
Self::RustcCaptureAnalysis =>
::core::fmt::Formatter::write_str(f, "RustcCaptureAnalysis"),
Self::RustcCguTestAttr(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcCguTestAttr", &__self_0),
Self::RustcClean(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcClean", &__self_0),
Self::RustcCoherenceIsCore =>
::core::fmt::Formatter::write_str(f, "RustcCoherenceIsCore"),
Self::RustcCoinductive =>
::core::fmt::Formatter::write_str(f, "RustcCoinductive"),
Self::RustcComptime(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcComptime", &__self_0),
Self::RustcConfusables { confusables: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcConfusables confusables", &__self_0),
Self::RustcConstStability { stability: __self_0, span: __self_1 }
=>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcConstStability stability span", __self_0, &__self_1),
Self::RustcConstStableIndirect =>
::core::fmt::Formatter::write_str(f,
"RustcConstStableIndirect"),
Self::RustcConversionSuggestion =>
::core::fmt::Formatter::write_str(f,
"RustcConversionSuggestion"),
Self::RustcDeallocator =>
::core::fmt::Formatter::write_str(f, "RustcDeallocator"),
Self::RustcDelayedBugFromInsideQuery =>
::core::fmt::Formatter::write_str(f,
"RustcDelayedBugFromInsideQuery"),
Self::RustcDenyExplicitImpl =>
::core::fmt::Formatter::write_str(f, "RustcDenyExplicitImpl"),
Self::RustcDeprecatedSafe2024 { suggestion: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDeprecatedSafe2024 suggestion", &__self_0),
Self::RustcDiagnosticItem(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDiagnosticItem", &__self_0),
Self::RustcDoNotConstCheck =>
::core::fmt::Formatter::write_str(f, "RustcDoNotConstCheck"),
Self::RustcDocPrimitive(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcDocPrimitive", __self_0, &__self_1),
Self::RustcDummy =>
::core::fmt::Formatter::write_str(f, "RustcDummy"),
Self::RustcDumpClauses =>
::core::fmt::Formatter::write_str(f, "RustcDumpClauses"),
Self::RustcDumpDefParents =>
::core::fmt::Formatter::write_str(f, "RustcDumpDefParents"),
Self::RustcDumpDefPath(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDumpDefPath", &__self_0),
Self::RustcDumpGenerics =>
::core::fmt::Formatter::write_str(f, "RustcDumpGenerics"),
Self::RustcDumpHiddenTypeOfOpaques =>
::core::fmt::Formatter::write_str(f,
"RustcDumpHiddenTypeOfOpaques"),
Self::RustcDumpInferredOutlives =>
::core::fmt::Formatter::write_str(f,
"RustcDumpInferredOutlives"),
Self::RustcDumpItemBounds =>
::core::fmt::Formatter::write_str(f, "RustcDumpItemBounds"),
Self::RustcDumpLayout(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDumpLayout", &__self_0),
Self::RustcDumpObjectLifetimeDefaults =>
::core::fmt::Formatter::write_str(f,
"RustcDumpObjectLifetimeDefaults"),
Self::RustcDumpSymbolName(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDumpSymbolName", &__self_0),
Self::RustcDumpUserArgs =>
::core::fmt::Formatter::write_str(f, "RustcDumpUserArgs"),
Self::RustcDumpVariances =>
::core::fmt::Formatter::write_str(f, "RustcDumpVariances"),
Self::RustcDumpVariancesOfOpaques =>
::core::fmt::Formatter::write_str(f,
"RustcDumpVariancesOfOpaques"),
Self::RustcDumpVtable(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDumpVtable", &__self_0),
Self::RustcDynIncompatibleTrait(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcDynIncompatibleTrait", &__self_0),
Self::RustcEffectiveVisibility =>
::core::fmt::Formatter::write_str(f,
"RustcEffectiveVisibility"),
Self::RustcEiiForeignItem =>
::core::fmt::Formatter::write_str(f, "RustcEiiForeignItem"),
Self::RustcEvaluateWhereClauses =>
::core::fmt::Formatter::write_str(f,
"RustcEvaluateWhereClauses"),
Self::RustcHasIncoherentInherentImpls =>
::core::fmt::Formatter::write_str(f,
"RustcHasIncoherentInherentImpls"),
Self::RustcIfThisChanged(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcIfThisChanged", __self_0, &__self_1),
Self::RustcInheritOverflowChecks =>
::core::fmt::Formatter::write_str(f,
"RustcInheritOverflowChecks"),
Self::RustcInsignificantDtor =>
::core::fmt::Formatter::write_str(f,
"RustcInsignificantDtor"),
Self::RustcIntrinsic { llvm: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcIntrinsic llvm", &__self_0),
Self::RustcIntrinsicConstStableIndirect =>
::core::fmt::Formatter::write_str(f,
"RustcIntrinsicConstStableIndirect"),
Self::RustcLegacyConstGenerics {
fn_indexes: __self_0, attr_span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcLegacyConstGenerics fn_indexes attr_span", __self_0,
&__self_1),
Self::RustcLintOptDenyFieldAccess { lint_message: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcLintOptDenyFieldAccess lint_message", &__self_0),
Self::RustcLintOptTy =>
::core::fmt::Formatter::write_str(f, "RustcLintOptTy"),
Self::RustcLintQueryInstability =>
::core::fmt::Formatter::write_str(f,
"RustcLintQueryInstability"),
Self::RustcLintUntrackedQueryInformation =>
::core::fmt::Formatter::write_str(f,
"RustcLintUntrackedQueryInformation"),
Self::RustcMacroTransparency(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcMacroTransparency", &__self_0),
Self::RustcMain =>
::core::fmt::Formatter::write_str(f, "RustcMain"),
Self::RustcMir(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcMir", &__self_0),
Self::RustcMustImplementOneOf {
attr_span: __self_0, fn_names: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcMustImplementOneOf attr_span fn_names", __self_0,
&__self_1),
Self::RustcMustMatchExhaustively(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcMustMatchExhaustively", &__self_0),
Self::RustcNoImplicitAutorefs =>
::core::fmt::Formatter::write_str(f,
"RustcNoImplicitAutorefs"),
Self::RustcNoImplicitBounds =>
::core::fmt::Formatter::write_str(f, "RustcNoImplicitBounds"),
Self::RustcNoMirInline =>
::core::fmt::Formatter::write_str(f, "RustcNoMirInline"),
Self::RustcNoWritable =>
::core::fmt::Formatter::write_str(f, "RustcNoWritable"),
Self::RustcNonConstTraitMethod =>
::core::fmt::Formatter::write_str(f,
"RustcNonConstTraitMethod"),
Self::RustcNonnullOptimizationGuaranteed =>
::core::fmt::Formatter::write_str(f,
"RustcNonnullOptimizationGuaranteed"),
Self::RustcNounwind =>
::core::fmt::Formatter::write_str(f, "RustcNounwind"),
Self::RustcObjcClass { classname: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcObjcClass classname", &__self_0),
Self::RustcObjcSelector { methname: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcObjcSelector methname", &__self_0),
Self::RustcOffloadKernel =>
::core::fmt::Formatter::write_str(f, "RustcOffloadKernel"),
Self::RustcPanicsWhenZero =>
::core::fmt::Formatter::write_str(f, "RustcPanicsWhenZero"),
Self::RustcParenSugar =>
::core::fmt::Formatter::write_str(f, "RustcParenSugar"),
Self::RustcPassByValue =>
::core::fmt::Formatter::write_str(f, "RustcPassByValue"),
Self::RustcPassIndirectlyInNonRusticAbis(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcPassIndirectlyInNonRusticAbis", &__self_0),
Self::RustcPreserveUbChecks =>
::core::fmt::Formatter::write_str(f, "RustcPreserveUbChecks"),
Self::RustcProcMacroDecls =>
::core::fmt::Formatter::write_str(f, "RustcProcMacroDecls"),
Self::RustcPubTransparent(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcPubTransparent", &__self_0),
Self::RustcReallocator =>
::core::fmt::Formatter::write_str(f, "RustcReallocator"),
Self::RustcRegions =>
::core::fmt::Formatter::write_str(f, "RustcRegions"),
Self::RustcScalableVector { element_count: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcScalableVector element_count", &__self_0),
Self::RustcShowSpans(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcShowSpans", &__self_0),
Self::RustcSimdMonomorphizeLaneLimit(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcSimdMonomorphizeLaneLimit", &__self_0),
Self::RustcSkipDuringMethodDispatch {
array: __self_0, boxed_slice: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"RustcSkipDuringMethodDispatch array boxed_slice", __self_0,
&__self_1),
Self::RustcSpecializationTrait =>
::core::fmt::Formatter::write_str(f,
"RustcSpecializationTrait"),
Self::RustcStdInternalSymbol =>
::core::fmt::Formatter::write_str(f,
"RustcStdInternalSymbol"),
Self::RustcStrictCoherence(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcStrictCoherence", &__self_0),
Self::RustcTestEntrypointMarker =>
::core::fmt::Formatter::write_str(f,
"RustcTestEntrypointMarker"),
Self::RustcTestMarker(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcTestMarker", &__self_0),
Self::RustcThenThisWouldNeed(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcThenThisWouldNeed", &__self_0),
Self::RustcTrivialFieldReads(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"RustcTrivialFieldReads", &__self_0),
Self::Sanitize {
on_set: __self_0,
off_set: __self_1,
rtsan: __self_2,
span: __self_3 } =>
::core::fmt::Formatter::debug_struct_field4_finish(f,
"Sanitize on_set off_set rtsan span", __self_0, __self_1,
__self_2, &__self_3),
Self::ShouldPanic { reason: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ShouldPanic reason", &__self_0),
Self::Splat(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Splat",
&__self_0),
Self::Stability { stability: __self_0, span: __self_1 } =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Stability stability span", __self_0, &__self_1),
Self::TargetFeature {
features: __self_0, attr_span: __self_1, was_forced: __self_2
} =>
::core::fmt::Formatter::debug_struct_field3_finish(f,
"TargetFeature features attr_span was_forced", __self_0,
__self_1, &__self_2),
Self::TestRunner(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"TestRunner", &__self_0),
Self::ThreadLocal =>
::core::fmt::Formatter::write_str(f, "ThreadLocal"),
Self::TrackCaller(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"TrackCaller", &__self_0),
Self::TypeLengthLimit { limit: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"TypeLengthLimit limit", &__self_0),
Self::UncheckedTypeAlias =>
::core::fmt::Formatter::write_str(f, "UncheckedTypeAlias"),
Self::Unroll(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Unroll", &__self_0),
Self::UnstableFeatureBound(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"UnstableFeatureBound", &__self_0),
Self::UnstableRemoved(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"UnstableRemoved", &__self_0),
Self::Used { used_by: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Used used_by", &__self_0),
Self::WindowsSubsystem(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"WindowsSubsystem", &__self_0),
}
}
}Debug, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for
AttributeKind {
#[inline]
fn stable_hash<__Hcx: ::rustc_data_structures::stable_hash::StableHashCtxt>(&self,
__hcx: &mut __Hcx,
__hasher:
&mut ::rustc_data_structures::stable_hash::StableHasher) {
match *self {
AttributeKind::AllowInternalUnsafe(ref __binding_0) =>
0u8.stable_hash(__hcx, __hasher),
AttributeKind::AllowInternalUnstable(ref __binding_0,
ref __binding_1) => 1u8.stable_hash(__hcx, __hasher),
AttributeKind::AlwaysGca =>
2u8.stable_hash(__hcx, __hasher),
AttributeKind::AutomaticallyDerived =>
3u8.stable_hash(__hcx, __hasher),
AttributeKind::CfgAttrTrace(ref __binding_0) =>
4u8.stable_hash(__hcx, __hasher),
AttributeKind::CfgTrace(ref __binding_0) =>
5u8.stable_hash(__hcx, __hasher),
AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
6u8.stable_hash(__hcx, __hasher),
AttributeKind::Cold => 7u8.stable_hash(__hcx, __hasher),
AttributeKind::CollapseDebugInfo(ref __binding_0) =>
8u8.stable_hash(__hcx, __hasher),
AttributeKind::CompilerBuiltins =>
9u8.stable_hash(__hcx, __hasher),
AttributeKind::ConstContinue(ref __binding_0) =>
10u8.stable_hash(__hcx, __hasher),
AttributeKind::Coroutine =>
11u8.stable_hash(__hcx, __hasher),
AttributeKind::Coverage(ref __binding_0) =>
12u8.stable_hash(__hcx, __hasher),
AttributeKind::CrateName {
name: ref __binding_0,
name_span: ref __binding_1,
attr_span: ref __binding_2 } =>
13u8.stable_hash(__hcx, __hasher),
AttributeKind::CrateType(ref __binding_0) =>
14u8.stable_hash(__hcx, __hasher),
AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
=> 15u8.stable_hash(__hcx, __hasher),
AttributeKind::DebuggerVisualizer(ref __binding_0) =>
16u8.stable_hash(__hcx, __hasher),
AttributeKind::DefaultLibAllocator =>
17u8.stable_hash(__hcx, __hasher),
AttributeKind::Deprecated {
deprecation: ref __binding_0,
span: ref __binding_1,
is_inner: ref __binding_2 } =>
18u8.stable_hash(__hcx, __hasher),
AttributeKind::DoNotRecommend =>
19u8.stable_hash(__hcx, __hasher),
AttributeKind::Doc(ref __binding_0) =>
20u8.stable_hash(__hcx, __hasher),
AttributeKind::DocComment {
style: ref __binding_0,
kind: ref __binding_1,
span: ref __binding_2,
comment: ref __binding_3 } =>
21u8.stable_hash(__hcx, __hasher),
AttributeKind::EiiDeclaration(ref __binding_0) =>
22u8.stable_hash(__hcx, __hasher),
AttributeKind::EiiImpl(ref __binding_0) =>
23u8.stable_hash(__hcx, __hasher),
AttributeKind::ExportName {
name: ref __binding_0, span: ref __binding_1 } =>
24u8.stable_hash(__hcx, __hasher),
AttributeKind::ExportStable =>
25u8.stable_hash(__hcx, __hasher),
AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
26u8.stable_hash(__hcx, __hasher),
AttributeKind::FfiConst =>
27u8.stable_hash(__hcx, __hasher),
AttributeKind::FfiPure(ref __binding_0) =>
28u8.stable_hash(__hcx, __hasher),
AttributeKind::Fundamental =>
29u8.stable_hash(__hcx, __hasher),
AttributeKind::Ignore {
span: ref __binding_0, reason: ref __binding_1 } =>
30u8.stable_hash(__hcx, __hasher),
AttributeKind::Inline(ref __binding_0, ref __binding_1) =>
31u8.stable_hash(__hcx, __hasher),
AttributeKind::InstructionSet(ref __binding_0) =>
32u8.stable_hash(__hcx, __hasher),
AttributeKind::InstrumentFn(ref __binding_0) =>
33u8.stable_hash(__hcx, __hasher),
AttributeKind::Lang(ref __binding_0) =>
34u8.stable_hash(__hcx, __hasher),
AttributeKind::Link(ref __binding_0, ref __binding_1) =>
35u8.stable_hash(__hcx, __hasher),
AttributeKind::LinkName {
name: ref __binding_0, span: ref __binding_1 } =>
36u8.stable_hash(__hcx, __hasher),
AttributeKind::LinkOrdinal {
ordinal: ref __binding_0, span: ref __binding_1 } =>
37u8.stable_hash(__hcx, __hasher),
AttributeKind::LinkSection { name: ref __binding_0 } =>
38u8.stable_hash(__hcx, __hasher),
AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
39u8.stable_hash(__hcx, __hasher),
AttributeKind::LintAsPtr =>
40u8.stable_hash(__hcx, __hasher),
AttributeKind::LintCheck(ref __binding_0) =>
41u8.stable_hash(__hcx, __hasher),
AttributeKind::LintNeverReturnsNullPtr =>
42u8.stable_hash(__hcx, __hasher),
AttributeKind::LintShouldNotBeCalledOnConstItems =>
43u8.stable_hash(__hcx, __hasher),
AttributeKind::LoopMatch(ref __binding_0) =>
44u8.stable_hash(__hcx, __hasher),
AttributeKind::MacroEscape =>
45u8.stable_hash(__hcx, __hasher),
AttributeKind::MacroExport {
span: ref __binding_0, local_inner_macros: ref __binding_1 }
=> 46u8.stable_hash(__hcx, __hasher),
AttributeKind::MacroUse {
span: ref __binding_0, arguments: ref __binding_1 } =>
47u8.stable_hash(__hcx, __hasher),
AttributeKind::Marker => 48u8.stable_hash(__hcx, __hasher),
AttributeKind::MayDangle(ref __binding_0) =>
49u8.stable_hash(__hcx, __hasher),
AttributeKind::MoveSizeLimit { limit: ref __binding_0 } =>
50u8.stable_hash(__hcx, __hasher),
AttributeKind::MustNotSuspend { reason: ref __binding_0 } =>
51u8.stable_hash(__hcx, __hasher),
AttributeKind::MustUse {
span: ref __binding_0, reason: ref __binding_1 } =>
52u8.stable_hash(__hcx, __hasher),
AttributeKind::Naked(ref __binding_0) =>
53u8.stable_hash(__hcx, __hasher),
AttributeKind::NeedsAllocator =>
54u8.stable_hash(__hcx, __hasher),
AttributeKind::NeedsPanicRuntime =>
55u8.stable_hash(__hcx, __hasher),
AttributeKind::NoBuiltins =>
56u8.stable_hash(__hcx, __hasher),
AttributeKind::NoCore => 57u8.stable_hash(__hcx, __hasher),
AttributeKind::NoImplicitPrelude =>
58u8.stable_hash(__hcx, __hasher),
AttributeKind::NoLink => 59u8.stable_hash(__hcx, __hasher),
AttributeKind::NoMain => 60u8.stable_hash(__hcx, __hasher),
AttributeKind::NoMangle(ref __binding_0) =>
61u8.stable_hash(__hcx, __hasher),
AttributeKind::NoStd => 62u8.stable_hash(__hcx, __hasher),
AttributeKind::NonExhaustive(ref __binding_0) =>
63u8.stable_hash(__hcx, __hasher),
AttributeKind::OnConst {
span: ref __binding_0, directive: ref __binding_1 } =>
64u8.stable_hash(__hcx, __hasher),
AttributeKind::OnMove { directive: ref __binding_0 } =>
65u8.stable_hash(__hcx, __hasher),
AttributeKind::OnTypeError {
span: ref __binding_0, directive: ref __binding_1 } =>
66u8.stable_hash(__hcx, __hasher),
AttributeKind::OnUnimplemented { directive: ref __binding_0
} => 67u8.stable_hash(__hcx, __hasher),
AttributeKind::OnUnknown { directive: ref __binding_0 } =>
68u8.stable_hash(__hcx, __hasher),
AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
} => 69u8.stable_hash(__hcx, __hasher),
AttributeKind::Opaque => 70u8.stable_hash(__hcx, __hasher),
AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
71u8.stable_hash(__hcx, __hasher),
AttributeKind::PanicRuntime =>
72u8.stable_hash(__hcx, __hasher),
AttributeKind::PatchableFunctionEntry {
prefix: ref __binding_0,
entry: ref __binding_1,
section: ref __binding_2 } =>
73u8.stable_hash(__hcx, __hasher),
AttributeKind::Path(ref __binding_0, ref __binding_1) =>
74u8.stable_hash(__hcx, __hasher),
AttributeKind::PatternComplexityLimit {
limit: ref __binding_0 } =>
75u8.stable_hash(__hcx, __hasher),
AttributeKind::PinV2(ref __binding_0) =>
76u8.stable_hash(__hcx, __hasher),
AttributeKind::PreludeImport =>
77u8.stable_hash(__hcx, __hasher),
AttributeKind::ProcMacro =>
78u8.stable_hash(__hcx, __hasher),
AttributeKind::ProcMacroAttribute =>
79u8.stable_hash(__hcx, __hasher),
AttributeKind::ProcMacroDerive {
trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
=> 80u8.stable_hash(__hcx, __hasher),
AttributeKind::ProfilerRuntime =>
81u8.stable_hash(__hcx, __hasher),
AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
82u8.stable_hash(__hcx, __hasher),
AttributeKind::ReexportTestHarnessMain(ref __binding_0) =>
83u8.stable_hash(__hcx, __hasher),
AttributeKind::RegisterTool {
attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
=> 84u8.stable_hash(__hcx, __hasher),
AttributeKind::Repr {
reprs: ref __binding_0, first_span: ref __binding_1 } =>
85u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAbi {
attr_span: ref __binding_0, kind: ref __binding_1 } =>
86u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAlign {
align: ref __binding_0, span: ref __binding_1 } =>
87u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAllocator =>
88u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAllocatorZeroed =>
89u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAllocatorZeroedVariant {
name: ref __binding_0 } =>
90u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
ref __binding_1) => 91u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
92u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAllowLifetimeDependentSpecialization =>
93u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAssertVariance {
span: ref __binding_0, kind: ref __binding_1 } =>
94u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcAutodiff(ref __binding_0) =>
95u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcBodyStability {
stability: ref __binding_0, span: ref __binding_1 } =>
96u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcBuiltinMacro {
builtin_name: ref __binding_0, helper_attrs: ref __binding_1
} => 97u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcCanonicalSymbol =>
98u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcCaptureAnalysis =>
99u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcCguTestAttr(ref __binding_0) =>
100u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcClean(ref __binding_0) =>
101u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcCoherenceIsCore =>
102u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcCoinductive =>
103u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcComptime(ref __binding_0) =>
104u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcConfusables {
confusables: ref __binding_0 } =>
105u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcConstStability {
stability: ref __binding_0, span: ref __binding_1 } =>
106u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcConstStableIndirect =>
107u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcConversionSuggestion =>
108u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDeallocator =>
109u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDelayedBugFromInsideQuery =>
110u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDenyExplicitImpl =>
111u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDeprecatedSafe2024 {
suggestion: ref __binding_0 } =>
112u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDiagnosticItem(ref __binding_0) =>
113u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDoNotConstCheck =>
114u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDocPrimitive(ref __binding_0,
ref __binding_1) => 115u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDummy =>
116u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpClauses =>
117u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpDefParents =>
118u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpDefPath(ref __binding_0) =>
119u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpGenerics =>
120u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpHiddenTypeOfOpaques =>
121u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpInferredOutlives =>
122u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpItemBounds =>
123u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpLayout(ref __binding_0) =>
124u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpObjectLifetimeDefaults =>
125u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpSymbolName(ref __binding_0) =>
126u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpUserArgs =>
127u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpVariances =>
128u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpVariancesOfOpaques =>
129u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDumpVtable(ref __binding_0) =>
130u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
131u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcEffectiveVisibility =>
132u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcEiiForeignItem =>
133u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcEvaluateWhereClauses =>
134u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcHasIncoherentInherentImpls =>
135u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcIfThisChanged(ref __binding_0,
ref __binding_1) => 136u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcInheritOverflowChecks =>
137u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcInsignificantDtor =>
138u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcIntrinsic { llvm: ref __binding_0 } =>
139u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcIntrinsicConstStableIndirect =>
140u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcLegacyConstGenerics {
fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
141u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcLintOptDenyFieldAccess {
lint_message: ref __binding_0 } =>
142u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcLintOptTy =>
143u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcLintQueryInstability =>
144u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcLintUntrackedQueryInformation =>
145u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcMacroTransparency(ref __binding_0) =>
146u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcMain =>
147u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcMir(ref __binding_0) =>
148u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcMustImplementOneOf {
attr_span: ref __binding_0, fn_names: ref __binding_1 } =>
149u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
=> 150u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNoImplicitAutorefs =>
151u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNoImplicitBounds =>
152u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNoMirInline =>
153u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNoWritable =>
154u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNonConstTraitMethod =>
155u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNonnullOptimizationGuaranteed =>
156u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcNounwind =>
157u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcObjcClass { classname: ref __binding_0 }
=> 158u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcObjcSelector { methname: ref __binding_0
} => 159u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcOffloadKernel =>
160u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcPanicsWhenZero =>
161u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcParenSugar =>
162u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcPassByValue =>
163u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
=> 164u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcPreserveUbChecks =>
165u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcProcMacroDecls =>
166u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcPubTransparent(ref __binding_0) =>
167u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcReallocator =>
168u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcRegions =>
169u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcScalableVector {
element_count: ref __binding_0 } =>
170u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcShowSpans(ref __binding_0) =>
171u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
=> 172u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcSkipDuringMethodDispatch {
array: ref __binding_0, boxed_slice: ref __binding_1 } =>
173u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcSpecializationTrait =>
174u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcStdInternalSymbol =>
175u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcStrictCoherence(ref __binding_0) =>
176u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcTestEntrypointMarker =>
177u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcTestMarker(ref __binding_0) =>
178u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcThenThisWouldNeed(ref __binding_0) =>
179u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcTrivialFieldReads(ref __binding_0) =>
180u8.stable_hash(__hcx, __hasher),
AttributeKind::Sanitize {
on_set: ref __binding_0,
off_set: ref __binding_1,
rtsan: ref __binding_2,
span: ref __binding_3 } =>
181u8.stable_hash(__hcx, __hasher),
AttributeKind::ShouldPanic { reason: ref __binding_0 } =>
182u8.stable_hash(__hcx, __hasher),
AttributeKind::Splat(ref __binding_0) =>
183u8.stable_hash(__hcx, __hasher),
AttributeKind::Stability {
stability: ref __binding_0, span: ref __binding_1 } =>
184u8.stable_hash(__hcx, __hasher),
AttributeKind::TargetFeature {
features: ref __binding_0,
attr_span: ref __binding_1,
was_forced: ref __binding_2 } =>
185u8.stable_hash(__hcx, __hasher),
AttributeKind::TestRunner(ref __binding_0) =>
186u8.stable_hash(__hcx, __hasher),
AttributeKind::ThreadLocal =>
187u8.stable_hash(__hcx, __hasher),
AttributeKind::TrackCaller(ref __binding_0) =>
188u8.stable_hash(__hcx, __hasher),
AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
189u8.stable_hash(__hcx, __hasher),
AttributeKind::UncheckedTypeAlias =>
190u8.stable_hash(__hcx, __hasher),
AttributeKind::Unroll(ref __binding_0) =>
191u8.stable_hash(__hcx, __hasher),
AttributeKind::UnstableFeatureBound(ref __binding_0) =>
192u8.stable_hash(__hcx, __hasher),
AttributeKind::UnstableRemoved(ref __binding_0) =>
193u8.stable_hash(__hcx, __hasher),
AttributeKind::Used { used_by: ref __binding_0 } =>
194u8.stable_hash(__hcx, __hasher),
AttributeKind::WindowsSubsystem(ref __binding_0) =>
195u8.stable_hash(__hcx, __hasher),
}
match *self {
AttributeKind::AllowInternalUnsafe(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::AllowInternalUnstable(ref __binding_0,
ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::AlwaysGca => {}
AttributeKind::AutomaticallyDerived => {}
AttributeKind::CfgAttrTrace(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::CfgTrace(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Cold => {}
AttributeKind::CollapseDebugInfo(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::CompilerBuiltins => {}
AttributeKind::ConstContinue(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Coroutine => {}
AttributeKind::Coverage(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::CrateName {
name: ref __binding_0,
name_span: ref __binding_1,
attr_span: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
AttributeKind::CrateType(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::DebuggerVisualizer(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::DefaultLibAllocator => {}
AttributeKind::Deprecated {
deprecation: ref __binding_0,
span: ref __binding_1,
is_inner: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
AttributeKind::DoNotRecommend => {}
AttributeKind::Doc(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::DocComment {
style: ref __binding_0,
kind: ref __binding_1,
span: ref __binding_2,
comment: ref __binding_3 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
}
AttributeKind::EiiDeclaration(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::EiiImpl(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::ExportName {
name: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::ExportStable => {}
AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::FfiConst => {}
AttributeKind::FfiPure(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Fundamental => {}
AttributeKind::Ignore {
span: ref __binding_0, reason: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::Inline(ref __binding_0, ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::InstructionSet(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::InstrumentFn(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Lang(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Link(ref __binding_0, ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::LinkName {
name: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::LinkOrdinal {
ordinal: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::LinkSection { name: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::LintAsPtr => {}
AttributeKind::LintCheck(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::LintNeverReturnsNullPtr => {}
AttributeKind::LintShouldNotBeCalledOnConstItems => {}
AttributeKind::LoopMatch(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::MacroEscape => {}
AttributeKind::MacroExport {
span: ref __binding_0, local_inner_macros: ref __binding_1 }
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::MacroUse {
span: ref __binding_0, arguments: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::Marker => {}
AttributeKind::MayDangle(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::MoveSizeLimit { limit: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::MustNotSuspend { reason: ref __binding_0 } =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::MustUse {
span: ref __binding_0, reason: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::Naked(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::NeedsAllocator => {}
AttributeKind::NeedsPanicRuntime => {}
AttributeKind::NoBuiltins => {}
AttributeKind::NoCore => {}
AttributeKind::NoImplicitPrelude => {}
AttributeKind::NoLink => {}
AttributeKind::NoMain => {}
AttributeKind::NoMangle(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::NoStd => {}
AttributeKind::NonExhaustive(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::OnConst {
span: ref __binding_0, directive: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::OnMove { directive: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::OnTypeError {
span: ref __binding_0, directive: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::OnUnimplemented { directive: ref __binding_0
} => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::OnUnknown { directive: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
} => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Opaque => {}
AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::PanicRuntime => {}
AttributeKind::PatchableFunctionEntry {
prefix: ref __binding_0,
entry: ref __binding_1,
section: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
AttributeKind::Path(ref __binding_0, ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::PatternComplexityLimit {
limit: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::PinV2(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::PreludeImport => {}
AttributeKind::ProcMacro => {}
AttributeKind::ProcMacroAttribute => {}
AttributeKind::ProcMacroDerive {
trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::ProfilerRuntime => {}
AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::ReexportTestHarnessMain(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RegisterTool {
attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::Repr {
reprs: ref __binding_0, first_span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAbi {
attr_span: ref __binding_0, kind: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAlign {
align: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAllocator => {}
AttributeKind::RustcAllocatorZeroed => {}
AttributeKind::RustcAllocatorZeroedVariant {
name: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAllowLifetimeDependentSpecialization =>
{}
AttributeKind::RustcAssertVariance {
span: ref __binding_0, kind: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcAutodiff(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcBodyStability {
stability: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcBuiltinMacro {
builtin_name: ref __binding_0, helper_attrs: ref __binding_1
} => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcCanonicalSymbol => {}
AttributeKind::RustcCaptureAnalysis => {}
AttributeKind::RustcCguTestAttr(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcClean(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcCoherenceIsCore => {}
AttributeKind::RustcCoinductive => {}
AttributeKind::RustcComptime(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcConfusables {
confusables: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcConstStability {
stability: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcConstStableIndirect => {}
AttributeKind::RustcConversionSuggestion => {}
AttributeKind::RustcDeallocator => {}
AttributeKind::RustcDelayedBugFromInsideQuery => {}
AttributeKind::RustcDenyExplicitImpl => {}
AttributeKind::RustcDeprecatedSafe2024 {
suggestion: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDiagnosticItem(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDoNotConstCheck => {}
AttributeKind::RustcDocPrimitive(ref __binding_0,
ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDummy => {}
AttributeKind::RustcDumpClauses => {}
AttributeKind::RustcDumpDefParents => {}
AttributeKind::RustcDumpDefPath(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDumpGenerics => {}
AttributeKind::RustcDumpHiddenTypeOfOpaques => {}
AttributeKind::RustcDumpInferredOutlives => {}
AttributeKind::RustcDumpItemBounds => {}
AttributeKind::RustcDumpLayout(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDumpObjectLifetimeDefaults => {}
AttributeKind::RustcDumpSymbolName(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDumpUserArgs => {}
AttributeKind::RustcDumpVariances => {}
AttributeKind::RustcDumpVariancesOfOpaques => {}
AttributeKind::RustcDumpVtable(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcEffectiveVisibility => {}
AttributeKind::RustcEiiForeignItem => {}
AttributeKind::RustcEvaluateWhereClauses => {}
AttributeKind::RustcHasIncoherentInherentImpls => {}
AttributeKind::RustcIfThisChanged(ref __binding_0,
ref __binding_1) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcInheritOverflowChecks => {}
AttributeKind::RustcInsignificantDtor => {}
AttributeKind::RustcIntrinsic { llvm: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcIntrinsicConstStableIndirect => {}
AttributeKind::RustcLegacyConstGenerics {
fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcLintOptDenyFieldAccess {
lint_message: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcLintOptTy => {}
AttributeKind::RustcLintQueryInstability => {}
AttributeKind::RustcLintUntrackedQueryInformation => {}
AttributeKind::RustcMacroTransparency(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcMain => {}
AttributeKind::RustcMir(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcMustImplementOneOf {
attr_span: ref __binding_0, fn_names: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcNoImplicitAutorefs => {}
AttributeKind::RustcNoImplicitBounds => {}
AttributeKind::RustcNoMirInline => {}
AttributeKind::RustcNoWritable => {}
AttributeKind::RustcNonConstTraitMethod => {}
AttributeKind::RustcNonnullOptimizationGuaranteed => {}
AttributeKind::RustcNounwind => {}
AttributeKind::RustcObjcClass { classname: ref __binding_0 }
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcObjcSelector { methname: ref __binding_0
} => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcOffloadKernel => {}
AttributeKind::RustcPanicsWhenZero => {}
AttributeKind::RustcParenSugar => {}
AttributeKind::RustcPassByValue => {}
AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcPreserveUbChecks => {}
AttributeKind::RustcProcMacroDecls => {}
AttributeKind::RustcPubTransparent(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcReallocator => {}
AttributeKind::RustcRegions => {}
AttributeKind::RustcScalableVector {
element_count: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcShowSpans(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
=> {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcSkipDuringMethodDispatch {
array: ref __binding_0, boxed_slice: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcSpecializationTrait => {}
AttributeKind::RustcStdInternalSymbol => {}
AttributeKind::RustcStrictCoherence(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcTestEntrypointMarker => {}
AttributeKind::RustcTestMarker(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcTrivialFieldReads(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Sanitize {
on_set: ref __binding_0,
off_set: ref __binding_1,
rtsan: ref __binding_2,
span: ref __binding_3 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
{ __binding_3.stable_hash(__hcx, __hasher); }
}
AttributeKind::ShouldPanic { reason: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Splat(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Stability {
stability: ref __binding_0, span: ref __binding_1 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
}
AttributeKind::TargetFeature {
features: ref __binding_0,
attr_span: ref __binding_1,
was_forced: ref __binding_2 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
{ __binding_1.stable_hash(__hcx, __hasher); }
{ __binding_2.stable_hash(__hcx, __hasher); }
}
AttributeKind::TestRunner(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::ThreadLocal => {}
AttributeKind::TrackCaller(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
{
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::UncheckedTypeAlias => {}
AttributeKind::Unroll(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::UnstableFeatureBound(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::UnstableRemoved(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::Used { used_by: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::WindowsSubsystem(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
}
}
}
};StableHash, const _: () =
{
impl<__E: ::rustc_span::SpanEncoder> ::rustc_serialize::Encodable<__E>
for AttributeKind {
fn encode(&self, __encoder: &mut __E) {
let disc =
match *self {
AttributeKind::AllowInternalUnsafe(ref __binding_0) => {
0usize
}
AttributeKind::AllowInternalUnstable(ref __binding_0,
ref __binding_1) => {
1usize
}
AttributeKind::AlwaysGca => { 2usize }
AttributeKind::AutomaticallyDerived => { 3usize }
AttributeKind::CfgAttrTrace(ref __binding_0) => { 4usize }
AttributeKind::CfgTrace(ref __binding_0) => { 5usize }
AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
{
6usize
}
AttributeKind::Cold => { 7usize }
AttributeKind::CollapseDebugInfo(ref __binding_0) => {
8usize
}
AttributeKind::CompilerBuiltins => { 9usize }
AttributeKind::ConstContinue(ref __binding_0) => { 10usize }
AttributeKind::Coroutine => { 11usize }
AttributeKind::Coverage(ref __binding_0) => { 12usize }
AttributeKind::CrateName {
name: ref __binding_0,
name_span: ref __binding_1,
attr_span: ref __binding_2 } => {
13usize
}
AttributeKind::CrateType(ref __binding_0) => { 14usize }
AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
=> {
15usize
}
AttributeKind::DebuggerVisualizer(ref __binding_0) => {
16usize
}
AttributeKind::DefaultLibAllocator => { 17usize }
AttributeKind::Deprecated {
deprecation: ref __binding_0,
span: ref __binding_1,
is_inner: ref __binding_2 } => {
18usize
}
AttributeKind::DoNotRecommend => { 19usize }
AttributeKind::Doc(ref __binding_0) => { 20usize }
AttributeKind::DocComment {
style: ref __binding_0,
kind: ref __binding_1,
span: ref __binding_2,
comment: ref __binding_3 } => {
21usize
}
AttributeKind::EiiDeclaration(ref __binding_0) => {
22usize
}
AttributeKind::EiiImpl(ref __binding_0) => { 23usize }
AttributeKind::ExportName {
name: ref __binding_0, span: ref __binding_1 } => {
24usize
}
AttributeKind::ExportStable => { 25usize }
AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
{
26usize
}
AttributeKind::FfiConst => { 27usize }
AttributeKind::FfiPure(ref __binding_0) => { 28usize }
AttributeKind::Fundamental => { 29usize }
AttributeKind::Ignore {
span: ref __binding_0, reason: ref __binding_1 } => {
30usize
}
AttributeKind::Inline(ref __binding_0, ref __binding_1) => {
31usize
}
AttributeKind::InstructionSet(ref __binding_0) => {
32usize
}
AttributeKind::InstrumentFn(ref __binding_0) => { 33usize }
AttributeKind::Lang(ref __binding_0) => { 34usize }
AttributeKind::Link(ref __binding_0, ref __binding_1) => {
35usize
}
AttributeKind::LinkName {
name: ref __binding_0, span: ref __binding_1 } => {
36usize
}
AttributeKind::LinkOrdinal {
ordinal: ref __binding_0, span: ref __binding_1 } => {
37usize
}
AttributeKind::LinkSection { name: ref __binding_0 } => {
38usize
}
AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
{
39usize
}
AttributeKind::LintAsPtr => { 40usize }
AttributeKind::LintCheck(ref __binding_0) => { 41usize }
AttributeKind::LintNeverReturnsNullPtr => { 42usize }
AttributeKind::LintShouldNotBeCalledOnConstItems => {
43usize
}
AttributeKind::LoopMatch(ref __binding_0) => { 44usize }
AttributeKind::MacroEscape => { 45usize }
AttributeKind::MacroExport {
span: ref __binding_0, local_inner_macros: ref __binding_1 }
=> {
46usize
}
AttributeKind::MacroUse {
span: ref __binding_0, arguments: ref __binding_1 } => {
47usize
}
AttributeKind::Marker => { 48usize }
AttributeKind::MayDangle(ref __binding_0) => { 49usize }
AttributeKind::MoveSizeLimit { limit: ref __binding_0 } => {
50usize
}
AttributeKind::MustNotSuspend { reason: ref __binding_0 } =>
{
51usize
}
AttributeKind::MustUse {
span: ref __binding_0, reason: ref __binding_1 } => {
52usize
}
AttributeKind::Naked(ref __binding_0) => { 53usize }
AttributeKind::NeedsAllocator => { 54usize }
AttributeKind::NeedsPanicRuntime => { 55usize }
AttributeKind::NoBuiltins => { 56usize }
AttributeKind::NoCore => { 57usize }
AttributeKind::NoImplicitPrelude => { 58usize }
AttributeKind::NoLink => { 59usize }
AttributeKind::NoMain => { 60usize }
AttributeKind::NoMangle(ref __binding_0) => { 61usize }
AttributeKind::NoStd => { 62usize }
AttributeKind::NonExhaustive(ref __binding_0) => { 63usize }
AttributeKind::OnConst {
span: ref __binding_0, directive: ref __binding_1 } => {
64usize
}
AttributeKind::OnMove { directive: ref __binding_0 } => {
65usize
}
AttributeKind::OnTypeError {
span: ref __binding_0, directive: ref __binding_1 } => {
66usize
}
AttributeKind::OnUnimplemented { directive: ref __binding_0
} => {
67usize
}
AttributeKind::OnUnknown { directive: ref __binding_0 } => {
68usize
}
AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
} => {
69usize
}
AttributeKind::Opaque => { 70usize }
AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
{
71usize
}
AttributeKind::PanicRuntime => { 72usize }
AttributeKind::PatchableFunctionEntry {
prefix: ref __binding_0,
entry: ref __binding_1,
section: ref __binding_2 } => {
73usize
}
AttributeKind::Path(ref __binding_0, ref __binding_1) => {
74usize
}
AttributeKind::PatternComplexityLimit {
limit: ref __binding_0 } => {
75usize
}
AttributeKind::PinV2(ref __binding_0) => { 76usize }
AttributeKind::PreludeImport => { 77usize }
AttributeKind::ProcMacro => { 78usize }
AttributeKind::ProcMacroAttribute => { 79usize }
AttributeKind::ProcMacroDerive {
trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
=> {
80usize
}
AttributeKind::ProfilerRuntime => { 81usize }
AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
{
82usize
}
AttributeKind::ReexportTestHarnessMain(ref __binding_0) => {
83usize
}
AttributeKind::RegisterTool {
attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
=> {
84usize
}
AttributeKind::Repr {
reprs: ref __binding_0, first_span: ref __binding_1 } => {
85usize
}
AttributeKind::RustcAbi {
attr_span: ref __binding_0, kind: ref __binding_1 } => {
86usize
}
AttributeKind::RustcAlign {
align: ref __binding_0, span: ref __binding_1 } => {
87usize
}
AttributeKind::RustcAllocator => { 88usize }
AttributeKind::RustcAllocatorZeroed => { 89usize }
AttributeKind::RustcAllocatorZeroedVariant {
name: ref __binding_0 } => {
90usize
}
AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
ref __binding_1) => {
91usize
}
AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
{
92usize
}
AttributeKind::RustcAllowLifetimeDependentSpecialization =>
{
93usize
}
AttributeKind::RustcAssertVariance {
span: ref __binding_0, kind: ref __binding_1 } => {
94usize
}
AttributeKind::RustcAutodiff(ref __binding_0) => { 95usize }
AttributeKind::RustcBodyStability {
stability: ref __binding_0, span: ref __binding_1 } => {
96usize
}
AttributeKind::RustcBuiltinMacro {
builtin_name: ref __binding_0, helper_attrs: ref __binding_1
} => {
97usize
}
AttributeKind::RustcCanonicalSymbol => { 98usize }
AttributeKind::RustcCaptureAnalysis => { 99usize }
AttributeKind::RustcCguTestAttr(ref __binding_0) => {
100usize
}
AttributeKind::RustcClean(ref __binding_0) => { 101usize }
AttributeKind::RustcCoherenceIsCore => { 102usize }
AttributeKind::RustcCoinductive => { 103usize }
AttributeKind::RustcComptime(ref __binding_0) => {
104usize
}
AttributeKind::RustcConfusables {
confusables: ref __binding_0 } => {
105usize
}
AttributeKind::RustcConstStability {
stability: ref __binding_0, span: ref __binding_1 } => {
106usize
}
AttributeKind::RustcConstStableIndirect => { 107usize }
AttributeKind::RustcConversionSuggestion => { 108usize }
AttributeKind::RustcDeallocator => { 109usize }
AttributeKind::RustcDelayedBugFromInsideQuery => {
110usize
}
AttributeKind::RustcDenyExplicitImpl => { 111usize }
AttributeKind::RustcDeprecatedSafe2024 {
suggestion: ref __binding_0 } => {
112usize
}
AttributeKind::RustcDiagnosticItem(ref __binding_0) => {
113usize
}
AttributeKind::RustcDoNotConstCheck => { 114usize }
AttributeKind::RustcDocPrimitive(ref __binding_0,
ref __binding_1) => {
115usize
}
AttributeKind::RustcDummy => { 116usize }
AttributeKind::RustcDumpClauses => { 117usize }
AttributeKind::RustcDumpDefParents => { 118usize }
AttributeKind::RustcDumpDefPath(ref __binding_0) => {
119usize
}
AttributeKind::RustcDumpGenerics => { 120usize }
AttributeKind::RustcDumpHiddenTypeOfOpaques => { 121usize }
AttributeKind::RustcDumpInferredOutlives => { 122usize }
AttributeKind::RustcDumpItemBounds => { 123usize }
AttributeKind::RustcDumpLayout(ref __binding_0) => {
124usize
}
AttributeKind::RustcDumpObjectLifetimeDefaults => {
125usize
}
AttributeKind::RustcDumpSymbolName(ref __binding_0) => {
126usize
}
AttributeKind::RustcDumpUserArgs => { 127usize }
AttributeKind::RustcDumpVariances => { 128usize }
AttributeKind::RustcDumpVariancesOfOpaques => { 129usize }
AttributeKind::RustcDumpVtable(ref __binding_0) => {
130usize
}
AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
{
131usize
}
AttributeKind::RustcEffectiveVisibility => { 132usize }
AttributeKind::RustcEiiForeignItem => { 133usize }
AttributeKind::RustcEvaluateWhereClauses => { 134usize }
AttributeKind::RustcHasIncoherentInherentImpls => {
135usize
}
AttributeKind::RustcIfThisChanged(ref __binding_0,
ref __binding_1) => {
136usize
}
AttributeKind::RustcInheritOverflowChecks => { 137usize }
AttributeKind::RustcInsignificantDtor => { 138usize }
AttributeKind::RustcIntrinsic { llvm: ref __binding_0 } => {
139usize
}
AttributeKind::RustcIntrinsicConstStableIndirect => {
140usize
}
AttributeKind::RustcLegacyConstGenerics {
fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
{
141usize
}
AttributeKind::RustcLintOptDenyFieldAccess {
lint_message: ref __binding_0 } => {
142usize
}
AttributeKind::RustcLintOptTy => { 143usize }
AttributeKind::RustcLintQueryInstability => { 144usize }
AttributeKind::RustcLintUntrackedQueryInformation => {
145usize
}
AttributeKind::RustcMacroTransparency(ref __binding_0) => {
146usize
}
AttributeKind::RustcMain => { 147usize }
AttributeKind::RustcMir(ref __binding_0) => { 148usize }
AttributeKind::RustcMustImplementOneOf {
attr_span: ref __binding_0, fn_names: ref __binding_1 } => {
149usize
}
AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
=> {
150usize
}
AttributeKind::RustcNoImplicitAutorefs => { 151usize }
AttributeKind::RustcNoImplicitBounds => { 152usize }
AttributeKind::RustcNoMirInline => { 153usize }
AttributeKind::RustcNoWritable => { 154usize }
AttributeKind::RustcNonConstTraitMethod => { 155usize }
AttributeKind::RustcNonnullOptimizationGuaranteed => {
156usize
}
AttributeKind::RustcNounwind => { 157usize }
AttributeKind::RustcObjcClass { classname: ref __binding_0 }
=> {
158usize
}
AttributeKind::RustcObjcSelector { methname: ref __binding_0
} => {
159usize
}
AttributeKind::RustcOffloadKernel => { 160usize }
AttributeKind::RustcPanicsWhenZero => { 161usize }
AttributeKind::RustcParenSugar => { 162usize }
AttributeKind::RustcPassByValue => { 163usize }
AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
=> {
164usize
}
AttributeKind::RustcPreserveUbChecks => { 165usize }
AttributeKind::RustcProcMacroDecls => { 166usize }
AttributeKind::RustcPubTransparent(ref __binding_0) => {
167usize
}
AttributeKind::RustcReallocator => { 168usize }
AttributeKind::RustcRegions => { 169usize }
AttributeKind::RustcScalableVector {
element_count: ref __binding_0 } => {
170usize
}
AttributeKind::RustcShowSpans(ref __binding_0) => {
171usize
}
AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
=> {
172usize
}
AttributeKind::RustcSkipDuringMethodDispatch {
array: ref __binding_0, boxed_slice: ref __binding_1 } => {
173usize
}
AttributeKind::RustcSpecializationTrait => { 174usize }
AttributeKind::RustcStdInternalSymbol => { 175usize }
AttributeKind::RustcStrictCoherence(ref __binding_0) => {
176usize
}
AttributeKind::RustcTestEntrypointMarker => { 177usize }
AttributeKind::RustcTestMarker(ref __binding_0) => {
178usize
}
AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
179usize
}
AttributeKind::RustcTrivialFieldReads(ref __binding_0) => {
180usize
}
AttributeKind::Sanitize {
on_set: ref __binding_0,
off_set: ref __binding_1,
rtsan: ref __binding_2,
span: ref __binding_3 } => {
181usize
}
AttributeKind::ShouldPanic { reason: ref __binding_0 } => {
182usize
}
AttributeKind::Splat(ref __binding_0) => { 183usize }
AttributeKind::Stability {
stability: ref __binding_0, span: ref __binding_1 } => {
184usize
}
AttributeKind::TargetFeature {
features: ref __binding_0,
attr_span: ref __binding_1,
was_forced: ref __binding_2 } => {
185usize
}
AttributeKind::TestRunner(ref __binding_0) => { 186usize }
AttributeKind::ThreadLocal => { 187usize }
AttributeKind::TrackCaller(ref __binding_0) => { 188usize }
AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
{
189usize
}
AttributeKind::UncheckedTypeAlias => { 190usize }
AttributeKind::Unroll(ref __binding_0) => { 191usize }
AttributeKind::UnstableFeatureBound(ref __binding_0) => {
192usize
}
AttributeKind::UnstableRemoved(ref __binding_0) => {
193usize
}
AttributeKind::Used { used_by: ref __binding_0 } => {
194usize
}
AttributeKind::WindowsSubsystem(ref __binding_0) => {
195usize
}
};
::rustc_serialize::Encoder::emit_u8(__encoder, disc as u8);
match *self {
AttributeKind::AllowInternalUnsafe(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::AllowInternalUnstable(ref __binding_0,
ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::AlwaysGca => {}
AttributeKind::AutomaticallyDerived => {}
AttributeKind::CfgAttrTrace(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::CfgTrace(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::CfiEncoding { encoding: ref __binding_0 } =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Cold => {}
AttributeKind::CollapseDebugInfo(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::CompilerBuiltins => {}
AttributeKind::ConstContinue(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Coroutine => {}
AttributeKind::Coverage(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::CrateName {
name: ref __binding_0,
name_span: ref __binding_1,
attr_span: ref __binding_2 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
AttributeKind::CrateType(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::CustomMir(ref __binding_0, ref __binding_1)
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::DebuggerVisualizer(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::DefaultLibAllocator => {}
AttributeKind::Deprecated {
deprecation: ref __binding_0,
span: ref __binding_1,
is_inner: ref __binding_2 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
AttributeKind::DoNotRecommend => {}
AttributeKind::Doc(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::DocComment {
style: ref __binding_0,
kind: ref __binding_1,
span: ref __binding_2,
comment: ref __binding_3 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
}
AttributeKind::EiiDeclaration(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::EiiImpl(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::ExportName {
name: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::ExportStable => {}
AttributeKind::Feature(ref __binding_0, ref __binding_1) =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::FfiConst => {}
AttributeKind::FfiPure(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Fundamental => {}
AttributeKind::Ignore {
span: ref __binding_0, reason: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::Inline(ref __binding_0, ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::InstructionSet(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::InstrumentFn(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Lang(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Link(ref __binding_0, ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::LinkName {
name: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::LinkOrdinal {
ordinal: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::LinkSection { name: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Linkage(ref __binding_0, ref __binding_1) =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::LintAsPtr => {}
AttributeKind::LintCheck(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::LintNeverReturnsNullPtr => {}
AttributeKind::LintShouldNotBeCalledOnConstItems => {}
AttributeKind::LoopMatch(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::MacroEscape => {}
AttributeKind::MacroExport {
span: ref __binding_0, local_inner_macros: ref __binding_1 }
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::MacroUse {
span: ref __binding_0, arguments: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::Marker => {}
AttributeKind::MayDangle(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::MoveSizeLimit { limit: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::MustNotSuspend { reason: ref __binding_0 } =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::MustUse {
span: ref __binding_0, reason: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::Naked(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::NeedsAllocator => {}
AttributeKind::NeedsPanicRuntime => {}
AttributeKind::NoBuiltins => {}
AttributeKind::NoCore => {}
AttributeKind::NoImplicitPrelude => {}
AttributeKind::NoLink => {}
AttributeKind::NoMain => {}
AttributeKind::NoMangle(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::NoStd => {}
AttributeKind::NonExhaustive(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::OnConst {
span: ref __binding_0, directive: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::OnMove { directive: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::OnTypeError {
span: ref __binding_0, directive: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::OnUnimplemented { directive: ref __binding_0
} => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::OnUnknown { directive: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::OnUnmatchedArgs { directive: ref __binding_0
} => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Opaque => {}
AttributeKind::Optimize(ref __binding_0, ref __binding_1) =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::PanicRuntime => {}
AttributeKind::PatchableFunctionEntry {
prefix: ref __binding_0,
entry: ref __binding_1,
section: ref __binding_2 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
AttributeKind::Path(ref __binding_0, ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::PatternComplexityLimit {
limit: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::PinV2(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::PreludeImport => {}
AttributeKind::ProcMacro => {}
AttributeKind::ProcMacroAttribute => {}
AttributeKind::ProcMacroDerive {
trait_name: ref __binding_0, helper_attrs: ref __binding_1 }
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::ProfilerRuntime => {}
AttributeKind::RecursionLimit { limit: ref __binding_0 } =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::ReexportTestHarnessMain(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RegisterTool {
attr_tools: ref __binding_0, lint_tools: ref __binding_1 }
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::Repr {
reprs: ref __binding_0, first_span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcAbi {
attr_span: ref __binding_0, kind: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcAlign {
align: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcAllocator => {}
AttributeKind::RustcAllocatorZeroed => {}
AttributeKind::RustcAllocatorZeroedVariant {
name: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcAllowConstFnUnstable(ref __binding_0,
ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcAllowIncoherentImpl(ref __binding_0) =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcAllowLifetimeDependentSpecialization =>
{}
AttributeKind::RustcAssertVariance {
span: ref __binding_0, kind: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcAutodiff(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcBodyStability {
stability: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcBuiltinMacro {
builtin_name: ref __binding_0, helper_attrs: ref __binding_1
} => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcCanonicalSymbol => {}
AttributeKind::RustcCaptureAnalysis => {}
AttributeKind::RustcCguTestAttr(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcClean(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcCoherenceIsCore => {}
AttributeKind::RustcCoinductive => {}
AttributeKind::RustcComptime(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcConfusables {
confusables: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcConstStability {
stability: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcConstStableIndirect => {}
AttributeKind::RustcConversionSuggestion => {}
AttributeKind::RustcDeallocator => {}
AttributeKind::RustcDelayedBugFromInsideQuery => {}
AttributeKind::RustcDenyExplicitImpl => {}
AttributeKind::RustcDeprecatedSafe2024 {
suggestion: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcDiagnosticItem(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcDoNotConstCheck => {}
AttributeKind::RustcDocPrimitive(ref __binding_0,
ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcDummy => {}
AttributeKind::RustcDumpClauses => {}
AttributeKind::RustcDumpDefParents => {}
AttributeKind::RustcDumpDefPath(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcDumpGenerics => {}
AttributeKind::RustcDumpHiddenTypeOfOpaques => {}
AttributeKind::RustcDumpInferredOutlives => {}
AttributeKind::RustcDumpItemBounds => {}
AttributeKind::RustcDumpLayout(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcDumpObjectLifetimeDefaults => {}
AttributeKind::RustcDumpSymbolName(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcDumpUserArgs => {}
AttributeKind::RustcDumpVariances => {}
AttributeKind::RustcDumpVariancesOfOpaques => {}
AttributeKind::RustcDumpVtable(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcDynIncompatibleTrait(ref __binding_0) =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcEffectiveVisibility => {}
AttributeKind::RustcEiiForeignItem => {}
AttributeKind::RustcEvaluateWhereClauses => {}
AttributeKind::RustcHasIncoherentInherentImpls => {}
AttributeKind::RustcIfThisChanged(ref __binding_0,
ref __binding_1) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcInheritOverflowChecks => {}
AttributeKind::RustcInsignificantDtor => {}
AttributeKind::RustcIntrinsic { llvm: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcIntrinsicConstStableIndirect => {}
AttributeKind::RustcLegacyConstGenerics {
fn_indexes: ref __binding_0, attr_span: ref __binding_1 } =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcLintOptDenyFieldAccess {
lint_message: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcLintOptTy => {}
AttributeKind::RustcLintQueryInstability => {}
AttributeKind::RustcLintUntrackedQueryInformation => {}
AttributeKind::RustcMacroTransparency(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcMain => {}
AttributeKind::RustcMir(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcMustImplementOneOf {
attr_span: ref __binding_0, fn_names: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcMustMatchExhaustively(ref __binding_0)
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcNoImplicitAutorefs => {}
AttributeKind::RustcNoImplicitBounds => {}
AttributeKind::RustcNoMirInline => {}
AttributeKind::RustcNoWritable => {}
AttributeKind::RustcNonConstTraitMethod => {}
AttributeKind::RustcNonnullOptimizationGuaranteed => {}
AttributeKind::RustcNounwind => {}
AttributeKind::RustcObjcClass { classname: ref __binding_0 }
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcObjcSelector { methname: ref __binding_0
} => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcOffloadKernel => {}
AttributeKind::RustcPanicsWhenZero => {}
AttributeKind::RustcParenSugar => {}
AttributeKind::RustcPassByValue => {}
AttributeKind::RustcPassIndirectlyInNonRusticAbis(ref __binding_0)
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcPreserveUbChecks => {}
AttributeKind::RustcProcMacroDecls => {}
AttributeKind::RustcPubTransparent(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcReallocator => {}
AttributeKind::RustcRegions => {}
AttributeKind::RustcScalableVector {
element_count: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcShowSpans(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
=> {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcSkipDuringMethodDispatch {
array: ref __binding_0, boxed_slice: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::RustcSpecializationTrait => {}
AttributeKind::RustcStdInternalSymbol => {}
AttributeKind::RustcStrictCoherence(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcTestEntrypointMarker => {}
AttributeKind::RustcTestMarker(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::RustcTrivialFieldReads(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Sanitize {
on_set: ref __binding_0,
off_set: ref __binding_1,
rtsan: ref __binding_2,
span: ref __binding_3 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_3,
__encoder);
}
AttributeKind::ShouldPanic { reason: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Splat(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Stability {
stability: ref __binding_0, span: ref __binding_1 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
}
AttributeKind::TargetFeature {
features: ref __binding_0,
attr_span: ref __binding_1,
was_forced: ref __binding_2 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_1,
__encoder);
::rustc_serialize::Encodable::<__E>::encode(__binding_2,
__encoder);
}
AttributeKind::TestRunner(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::ThreadLocal => {}
AttributeKind::TrackCaller(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::TypeLengthLimit { limit: ref __binding_0 } =>
{
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::UncheckedTypeAlias => {}
AttributeKind::Unroll(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::UnstableFeatureBound(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::UnstableRemoved(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::Used { used_by: ref __binding_0 } => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
AttributeKind::WindowsSubsystem(ref __binding_0) => {
::rustc_serialize::Encodable::<__E>::encode(__binding_0,
__encoder);
}
}
}
}
};Encodable, const _: () =
{
impl<__D: ::rustc_span::SpanDecoder> ::rustc_serialize::Decodable<__D>
for AttributeKind {
fn decode(__decoder: &mut __D) -> Self {
match ::rustc_serialize::Decoder::read_u8(__decoder) as usize
{
0usize => {
AttributeKind::AllowInternalUnsafe(::rustc_serialize::Decodable::decode(__decoder))
}
1usize => {
AttributeKind::AllowInternalUnstable(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
2usize => { AttributeKind::AlwaysGca }
3usize => { AttributeKind::AutomaticallyDerived }
4usize => {
AttributeKind::CfgAttrTrace(::rustc_serialize::Decodable::decode(__decoder))
}
5usize => {
AttributeKind::CfgTrace(::rustc_serialize::Decodable::decode(__decoder))
}
6usize => {
AttributeKind::CfiEncoding {
encoding: ::rustc_serialize::Decodable::decode(__decoder),
}
}
7usize => { AttributeKind::Cold }
8usize => {
AttributeKind::CollapseDebugInfo(::rustc_serialize::Decodable::decode(__decoder))
}
9usize => { AttributeKind::CompilerBuiltins }
10usize => {
AttributeKind::ConstContinue(::rustc_serialize::Decodable::decode(__decoder))
}
11usize => { AttributeKind::Coroutine }
12usize => {
AttributeKind::Coverage(::rustc_serialize::Decodable::decode(__decoder))
}
13usize => {
AttributeKind::CrateName {
name: ::rustc_serialize::Decodable::decode(__decoder),
name_span: ::rustc_serialize::Decodable::decode(__decoder),
attr_span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
14usize => {
AttributeKind::CrateType(::rustc_serialize::Decodable::decode(__decoder))
}
15usize => {
AttributeKind::CustomMir(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
16usize => {
AttributeKind::DebuggerVisualizer(::rustc_serialize::Decodable::decode(__decoder))
}
17usize => { AttributeKind::DefaultLibAllocator }
18usize => {
AttributeKind::Deprecated {
deprecation: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
is_inner: ::rustc_serialize::Decodable::decode(__decoder),
}
}
19usize => { AttributeKind::DoNotRecommend }
20usize => {
AttributeKind::Doc(::rustc_serialize::Decodable::decode(__decoder))
}
21usize => {
AttributeKind::DocComment {
style: ::rustc_serialize::Decodable::decode(__decoder),
kind: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
comment: ::rustc_serialize::Decodable::decode(__decoder),
}
}
22usize => {
AttributeKind::EiiDeclaration(::rustc_serialize::Decodable::decode(__decoder))
}
23usize => {
AttributeKind::EiiImpl(::rustc_serialize::Decodable::decode(__decoder))
}
24usize => {
AttributeKind::ExportName {
name: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
25usize => { AttributeKind::ExportStable }
26usize => {
AttributeKind::Feature(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
27usize => { AttributeKind::FfiConst }
28usize => {
AttributeKind::FfiPure(::rustc_serialize::Decodable::decode(__decoder))
}
29usize => { AttributeKind::Fundamental }
30usize => {
AttributeKind::Ignore {
span: ::rustc_serialize::Decodable::decode(__decoder),
reason: ::rustc_serialize::Decodable::decode(__decoder),
}
}
31usize => {
AttributeKind::Inline(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
32usize => {
AttributeKind::InstructionSet(::rustc_serialize::Decodable::decode(__decoder))
}
33usize => {
AttributeKind::InstrumentFn(::rustc_serialize::Decodable::decode(__decoder))
}
34usize => {
AttributeKind::Lang(::rustc_serialize::Decodable::decode(__decoder))
}
35usize => {
AttributeKind::Link(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
36usize => {
AttributeKind::LinkName {
name: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
37usize => {
AttributeKind::LinkOrdinal {
ordinal: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
38usize => {
AttributeKind::LinkSection {
name: ::rustc_serialize::Decodable::decode(__decoder),
}
}
39usize => {
AttributeKind::Linkage(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
40usize => { AttributeKind::LintAsPtr }
41usize => {
AttributeKind::LintCheck(::rustc_serialize::Decodable::decode(__decoder))
}
42usize => { AttributeKind::LintNeverReturnsNullPtr }
43usize => {
AttributeKind::LintShouldNotBeCalledOnConstItems
}
44usize => {
AttributeKind::LoopMatch(::rustc_serialize::Decodable::decode(__decoder))
}
45usize => { AttributeKind::MacroEscape }
46usize => {
AttributeKind::MacroExport {
span: ::rustc_serialize::Decodable::decode(__decoder),
local_inner_macros: ::rustc_serialize::Decodable::decode(__decoder),
}
}
47usize => {
AttributeKind::MacroUse {
span: ::rustc_serialize::Decodable::decode(__decoder),
arguments: ::rustc_serialize::Decodable::decode(__decoder),
}
}
48usize => { AttributeKind::Marker }
49usize => {
AttributeKind::MayDangle(::rustc_serialize::Decodable::decode(__decoder))
}
50usize => {
AttributeKind::MoveSizeLimit {
limit: ::rustc_serialize::Decodable::decode(__decoder),
}
}
51usize => {
AttributeKind::MustNotSuspend {
reason: ::rustc_serialize::Decodable::decode(__decoder),
}
}
52usize => {
AttributeKind::MustUse {
span: ::rustc_serialize::Decodable::decode(__decoder),
reason: ::rustc_serialize::Decodable::decode(__decoder),
}
}
53usize => {
AttributeKind::Naked(::rustc_serialize::Decodable::decode(__decoder))
}
54usize => { AttributeKind::NeedsAllocator }
55usize => { AttributeKind::NeedsPanicRuntime }
56usize => { AttributeKind::NoBuiltins }
57usize => { AttributeKind::NoCore }
58usize => { AttributeKind::NoImplicitPrelude }
59usize => { AttributeKind::NoLink }
60usize => { AttributeKind::NoMain }
61usize => {
AttributeKind::NoMangle(::rustc_serialize::Decodable::decode(__decoder))
}
62usize => { AttributeKind::NoStd }
63usize => {
AttributeKind::NonExhaustive(::rustc_serialize::Decodable::decode(__decoder))
}
64usize => {
AttributeKind::OnConst {
span: ::rustc_serialize::Decodable::decode(__decoder),
directive: ::rustc_serialize::Decodable::decode(__decoder),
}
}
65usize => {
AttributeKind::OnMove {
directive: ::rustc_serialize::Decodable::decode(__decoder),
}
}
66usize => {
AttributeKind::OnTypeError {
span: ::rustc_serialize::Decodable::decode(__decoder),
directive: ::rustc_serialize::Decodable::decode(__decoder),
}
}
67usize => {
AttributeKind::OnUnimplemented {
directive: ::rustc_serialize::Decodable::decode(__decoder),
}
}
68usize => {
AttributeKind::OnUnknown {
directive: ::rustc_serialize::Decodable::decode(__decoder),
}
}
69usize => {
AttributeKind::OnUnmatchedArgs {
directive: ::rustc_serialize::Decodable::decode(__decoder),
}
}
70usize => { AttributeKind::Opaque }
71usize => {
AttributeKind::Optimize(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
72usize => { AttributeKind::PanicRuntime }
73usize => {
AttributeKind::PatchableFunctionEntry {
prefix: ::rustc_serialize::Decodable::decode(__decoder),
entry: ::rustc_serialize::Decodable::decode(__decoder),
section: ::rustc_serialize::Decodable::decode(__decoder),
}
}
74usize => {
AttributeKind::Path(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
75usize => {
AttributeKind::PatternComplexityLimit {
limit: ::rustc_serialize::Decodable::decode(__decoder),
}
}
76usize => {
AttributeKind::PinV2(::rustc_serialize::Decodable::decode(__decoder))
}
77usize => { AttributeKind::PreludeImport }
78usize => { AttributeKind::ProcMacro }
79usize => { AttributeKind::ProcMacroAttribute }
80usize => {
AttributeKind::ProcMacroDerive {
trait_name: ::rustc_serialize::Decodable::decode(__decoder),
helper_attrs: ::rustc_serialize::Decodable::decode(__decoder),
}
}
81usize => { AttributeKind::ProfilerRuntime }
82usize => {
AttributeKind::RecursionLimit {
limit: ::rustc_serialize::Decodable::decode(__decoder),
}
}
83usize => {
AttributeKind::ReexportTestHarnessMain(::rustc_serialize::Decodable::decode(__decoder))
}
84usize => {
AttributeKind::RegisterTool {
attr_tools: ::rustc_serialize::Decodable::decode(__decoder),
lint_tools: ::rustc_serialize::Decodable::decode(__decoder),
}
}
85usize => {
AttributeKind::Repr {
reprs: ::rustc_serialize::Decodable::decode(__decoder),
first_span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
86usize => {
AttributeKind::RustcAbi {
attr_span: ::rustc_serialize::Decodable::decode(__decoder),
kind: ::rustc_serialize::Decodable::decode(__decoder),
}
}
87usize => {
AttributeKind::RustcAlign {
align: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
88usize => { AttributeKind::RustcAllocator }
89usize => { AttributeKind::RustcAllocatorZeroed }
90usize => {
AttributeKind::RustcAllocatorZeroedVariant {
name: ::rustc_serialize::Decodable::decode(__decoder),
}
}
91usize => {
AttributeKind::RustcAllowConstFnUnstable(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
92usize => {
AttributeKind::RustcAllowIncoherentImpl(::rustc_serialize::Decodable::decode(__decoder))
}
93usize => {
AttributeKind::RustcAllowLifetimeDependentSpecialization
}
94usize => {
AttributeKind::RustcAssertVariance {
span: ::rustc_serialize::Decodable::decode(__decoder),
kind: ::rustc_serialize::Decodable::decode(__decoder),
}
}
95usize => {
AttributeKind::RustcAutodiff(::rustc_serialize::Decodable::decode(__decoder))
}
96usize => {
AttributeKind::RustcBodyStability {
stability: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
97usize => {
AttributeKind::RustcBuiltinMacro {
builtin_name: ::rustc_serialize::Decodable::decode(__decoder),
helper_attrs: ::rustc_serialize::Decodable::decode(__decoder),
}
}
98usize => { AttributeKind::RustcCanonicalSymbol }
99usize => { AttributeKind::RustcCaptureAnalysis }
100usize => {
AttributeKind::RustcCguTestAttr(::rustc_serialize::Decodable::decode(__decoder))
}
101usize => {
AttributeKind::RustcClean(::rustc_serialize::Decodable::decode(__decoder))
}
102usize => { AttributeKind::RustcCoherenceIsCore }
103usize => { AttributeKind::RustcCoinductive }
104usize => {
AttributeKind::RustcComptime(::rustc_serialize::Decodable::decode(__decoder))
}
105usize => {
AttributeKind::RustcConfusables {
confusables: ::rustc_serialize::Decodable::decode(__decoder),
}
}
106usize => {
AttributeKind::RustcConstStability {
stability: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
107usize => { AttributeKind::RustcConstStableIndirect }
108usize => { AttributeKind::RustcConversionSuggestion }
109usize => { AttributeKind::RustcDeallocator }
110usize => {
AttributeKind::RustcDelayedBugFromInsideQuery
}
111usize => { AttributeKind::RustcDenyExplicitImpl }
112usize => {
AttributeKind::RustcDeprecatedSafe2024 {
suggestion: ::rustc_serialize::Decodable::decode(__decoder),
}
}
113usize => {
AttributeKind::RustcDiagnosticItem(::rustc_serialize::Decodable::decode(__decoder))
}
114usize => { AttributeKind::RustcDoNotConstCheck }
115usize => {
AttributeKind::RustcDocPrimitive(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
116usize => { AttributeKind::RustcDummy }
117usize => { AttributeKind::RustcDumpClauses }
118usize => { AttributeKind::RustcDumpDefParents }
119usize => {
AttributeKind::RustcDumpDefPath(::rustc_serialize::Decodable::decode(__decoder))
}
120usize => { AttributeKind::RustcDumpGenerics }
121usize => { AttributeKind::RustcDumpHiddenTypeOfOpaques }
122usize => { AttributeKind::RustcDumpInferredOutlives }
123usize => { AttributeKind::RustcDumpItemBounds }
124usize => {
AttributeKind::RustcDumpLayout(::rustc_serialize::Decodable::decode(__decoder))
}
125usize => {
AttributeKind::RustcDumpObjectLifetimeDefaults
}
126usize => {
AttributeKind::RustcDumpSymbolName(::rustc_serialize::Decodable::decode(__decoder))
}
127usize => { AttributeKind::RustcDumpUserArgs }
128usize => { AttributeKind::RustcDumpVariances }
129usize => { AttributeKind::RustcDumpVariancesOfOpaques }
130usize => {
AttributeKind::RustcDumpVtable(::rustc_serialize::Decodable::decode(__decoder))
}
131usize => {
AttributeKind::RustcDynIncompatibleTrait(::rustc_serialize::Decodable::decode(__decoder))
}
132usize => { AttributeKind::RustcEffectiveVisibility }
133usize => { AttributeKind::RustcEiiForeignItem }
134usize => { AttributeKind::RustcEvaluateWhereClauses }
135usize => {
AttributeKind::RustcHasIncoherentInherentImpls
}
136usize => {
AttributeKind::RustcIfThisChanged(::rustc_serialize::Decodable::decode(__decoder),
::rustc_serialize::Decodable::decode(__decoder))
}
137usize => { AttributeKind::RustcInheritOverflowChecks }
138usize => { AttributeKind::RustcInsignificantDtor }
139usize => {
AttributeKind::RustcIntrinsic {
llvm: ::rustc_serialize::Decodable::decode(__decoder),
}
}
140usize => {
AttributeKind::RustcIntrinsicConstStableIndirect
}
141usize => {
AttributeKind::RustcLegacyConstGenerics {
fn_indexes: ::rustc_serialize::Decodable::decode(__decoder),
attr_span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
142usize => {
AttributeKind::RustcLintOptDenyFieldAccess {
lint_message: ::rustc_serialize::Decodable::decode(__decoder),
}
}
143usize => { AttributeKind::RustcLintOptTy }
144usize => { AttributeKind::RustcLintQueryInstability }
145usize => {
AttributeKind::RustcLintUntrackedQueryInformation
}
146usize => {
AttributeKind::RustcMacroTransparency(::rustc_serialize::Decodable::decode(__decoder))
}
147usize => { AttributeKind::RustcMain }
148usize => {
AttributeKind::RustcMir(::rustc_serialize::Decodable::decode(__decoder))
}
149usize => {
AttributeKind::RustcMustImplementOneOf {
attr_span: ::rustc_serialize::Decodable::decode(__decoder),
fn_names: ::rustc_serialize::Decodable::decode(__decoder),
}
}
150usize => {
AttributeKind::RustcMustMatchExhaustively(::rustc_serialize::Decodable::decode(__decoder))
}
151usize => { AttributeKind::RustcNoImplicitAutorefs }
152usize => { AttributeKind::RustcNoImplicitBounds }
153usize => { AttributeKind::RustcNoMirInline }
154usize => { AttributeKind::RustcNoWritable }
155usize => { AttributeKind::RustcNonConstTraitMethod }
156usize => {
AttributeKind::RustcNonnullOptimizationGuaranteed
}
157usize => { AttributeKind::RustcNounwind }
158usize => {
AttributeKind::RustcObjcClass {
classname: ::rustc_serialize::Decodable::decode(__decoder),
}
}
159usize => {
AttributeKind::RustcObjcSelector {
methname: ::rustc_serialize::Decodable::decode(__decoder),
}
}
160usize => { AttributeKind::RustcOffloadKernel }
161usize => { AttributeKind::RustcPanicsWhenZero }
162usize => { AttributeKind::RustcParenSugar }
163usize => { AttributeKind::RustcPassByValue }
164usize => {
AttributeKind::RustcPassIndirectlyInNonRusticAbis(::rustc_serialize::Decodable::decode(__decoder))
}
165usize => { AttributeKind::RustcPreserveUbChecks }
166usize => { AttributeKind::RustcProcMacroDecls }
167usize => {
AttributeKind::RustcPubTransparent(::rustc_serialize::Decodable::decode(__decoder))
}
168usize => { AttributeKind::RustcReallocator }
169usize => { AttributeKind::RustcRegions }
170usize => {
AttributeKind::RustcScalableVector {
element_count: ::rustc_serialize::Decodable::decode(__decoder),
}
}
171usize => {
AttributeKind::RustcShowSpans(::rustc_serialize::Decodable::decode(__decoder))
}
172usize => {
AttributeKind::RustcSimdMonomorphizeLaneLimit(::rustc_serialize::Decodable::decode(__decoder))
}
173usize => {
AttributeKind::RustcSkipDuringMethodDispatch {
array: ::rustc_serialize::Decodable::decode(__decoder),
boxed_slice: ::rustc_serialize::Decodable::decode(__decoder),
}
}
174usize => { AttributeKind::RustcSpecializationTrait }
175usize => { AttributeKind::RustcStdInternalSymbol }
176usize => {
AttributeKind::RustcStrictCoherence(::rustc_serialize::Decodable::decode(__decoder))
}
177usize => { AttributeKind::RustcTestEntrypointMarker }
178usize => {
AttributeKind::RustcTestMarker(::rustc_serialize::Decodable::decode(__decoder))
}
179usize => {
AttributeKind::RustcThenThisWouldNeed(::rustc_serialize::Decodable::decode(__decoder))
}
180usize => {
AttributeKind::RustcTrivialFieldReads(::rustc_serialize::Decodable::decode(__decoder))
}
181usize => {
AttributeKind::Sanitize {
on_set: ::rustc_serialize::Decodable::decode(__decoder),
off_set: ::rustc_serialize::Decodable::decode(__decoder),
rtsan: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
182usize => {
AttributeKind::ShouldPanic {
reason: ::rustc_serialize::Decodable::decode(__decoder),
}
}
183usize => {
AttributeKind::Splat(::rustc_serialize::Decodable::decode(__decoder))
}
184usize => {
AttributeKind::Stability {
stability: ::rustc_serialize::Decodable::decode(__decoder),
span: ::rustc_serialize::Decodable::decode(__decoder),
}
}
185usize => {
AttributeKind::TargetFeature {
features: ::rustc_serialize::Decodable::decode(__decoder),
attr_span: ::rustc_serialize::Decodable::decode(__decoder),
was_forced: ::rustc_serialize::Decodable::decode(__decoder),
}
}
186usize => {
AttributeKind::TestRunner(::rustc_serialize::Decodable::decode(__decoder))
}
187usize => { AttributeKind::ThreadLocal }
188usize => {
AttributeKind::TrackCaller(::rustc_serialize::Decodable::decode(__decoder))
}
189usize => {
AttributeKind::TypeLengthLimit {
limit: ::rustc_serialize::Decodable::decode(__decoder),
}
}
190usize => { AttributeKind::UncheckedTypeAlias }
191usize => {
AttributeKind::Unroll(::rustc_serialize::Decodable::decode(__decoder))
}
192usize => {
AttributeKind::UnstableFeatureBound(::rustc_serialize::Decodable::decode(__decoder))
}
193usize => {
AttributeKind::UnstableRemoved(::rustc_serialize::Decodable::decode(__decoder))
}
194usize => {
AttributeKind::Used {
used_by: ::rustc_serialize::Decodable::decode(__decoder),
}
}
195usize => {
AttributeKind::WindowsSubsystem(::rustc_serialize::Decodable::decode(__decoder))
}
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `AttributeKind`, expected 0..196, actual {0}",
n));
}
}
}
}
};Decodable, const _: () =
{
#[allow(unused)]
impl PrintAttribute for AttributeKind {
fn should_render(&self) -> bool { true }
fn print_attribute(&self,
__p: &mut rustc_ast_pretty::pp::Printer) {
match self {
Self::AllowInternalUnsafe(f0) => {
__p.word("AllowInternalUnsafe");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::AllowInternalUnstable(f0, f1) => {
__p.word("AllowInternalUnstable");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::AlwaysGca => { __p.word("AlwaysGca") }
Self::AutomaticallyDerived => {
__p.word("AutomaticallyDerived")
}
Self::CfgAttrTrace(f0) => {
__p.word("CfgAttrTrace");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::CfgTrace(f0) => {
__p.word("CfgTrace");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::CfiEncoding { encoding } => {
__p.word("CfiEncoding");
if true && !encoding.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if encoding.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("encoding");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
encoding.print_attribute(__p);
__p.word("}");
}
Self::Cold => { __p.word("Cold") }
Self::CollapseDebugInfo(f0) => {
__p.word("CollapseDebugInfo");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::CompilerBuiltins => { __p.word("CompilerBuiltins") }
Self::ConstContinue(f0) => {
__p.word("ConstContinue");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Coroutine => { __p.word("Coroutine") }
Self::Coverage(f0) => {
__p.word("Coverage");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::CrateName { name, name_span, attr_span } => {
__p.word("CrateName");
if true && !name.should_render() &&
!name_span.should_render() && !attr_span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
if name_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name_span.print_attribute(__p);
if attr_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_span.print_attribute(__p);
__p.word("}");
}
Self::CrateType(f0) => {
__p.word("CrateType");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::CustomMir(f0, f1) => {
__p.word("CustomMir");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::DebuggerVisualizer(f0) => {
__p.word("DebuggerVisualizer");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::DefaultLibAllocator => {
__p.word("DefaultLibAllocator")
}
Self::Deprecated { deprecation, span, is_inner } => {
__p.word("Deprecated");
if true && !deprecation.should_render() &&
!span.should_render() && !is_inner.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if deprecation.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("deprecation");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
deprecation.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if is_inner.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("is_inner");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
is_inner.print_attribute(__p);
__p.word("}");
}
Self::DoNotRecommend => { __p.word("DoNotRecommend") }
Self::Doc(f0) => {
__p.word("Doc");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::DocComment { style, kind, span, comment } => {
__p.word("DocComment");
if true && !style.should_render() && !kind.should_render()
&& !span.should_render() && !comment.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if style.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("style");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
style.print_attribute(__p);
if kind.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("kind");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
kind.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if comment.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("comment");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
comment.print_attribute(__p);
__p.word("}");
}
Self::EiiDeclaration(f0) => {
__p.word("EiiDeclaration");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::EiiImpl(f0) => {
__p.word("EiiImpl");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::ExportName { name, span } => {
__p.word("ExportName");
if true && !name.should_render() && !span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::ExportStable => { __p.word("ExportStable") }
Self::Feature(f0, f1) => {
__p.word("Feature");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::FfiConst => { __p.word("FfiConst") }
Self::FfiPure(f0) => {
__p.word("FfiPure");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Fundamental => { __p.word("Fundamental") }
Self::Ignore { span, reason } => {
__p.word("Ignore");
if true && !span.should_render() && !reason.should_render()
{
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if reason.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reason");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reason.print_attribute(__p);
__p.word("}");
}
Self::Inline(f0, f1) => {
__p.word("Inline");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::InstructionSet(f0) => {
__p.word("InstructionSet");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::InstrumentFn(f0) => {
__p.word("InstrumentFn");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Lang(f0) => {
__p.word("Lang");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Link(f0, f1) => {
__p.word("Link");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::LinkName { name, span } => {
__p.word("LinkName");
if true && !name.should_render() && !span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::LinkOrdinal { ordinal, span } => {
__p.word("LinkOrdinal");
if true && !ordinal.should_render() && !span.should_render()
{
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if ordinal.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("ordinal");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
ordinal.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::LinkSection { name } => {
__p.word("LinkSection");
if true && !name.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
__p.word("}");
}
Self::Linkage(f0, f1) => {
__p.word("Linkage");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::LintAsPtr => { __p.word("LintAsPtr") }
Self::LintCheck(f0) => {
__p.word("LintCheck");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::LintNeverReturnsNullPtr => {
__p.word("LintNeverReturnsNullPtr")
}
Self::LintShouldNotBeCalledOnConstItems => {
__p.word("LintShouldNotBeCalledOnConstItems")
}
Self::LoopMatch(f0) => {
__p.word("LoopMatch");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::MacroEscape => { __p.word("MacroEscape") }
Self::MacroExport { span, local_inner_macros } => {
__p.word("MacroExport");
if true && !span.should_render() &&
!local_inner_macros.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if local_inner_macros.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("local_inner_macros");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
local_inner_macros.print_attribute(__p);
__p.word("}");
}
Self::MacroUse { span, arguments } => {
__p.word("MacroUse");
if true && !span.should_render() &&
!arguments.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if arguments.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("arguments");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
arguments.print_attribute(__p);
__p.word("}");
}
Self::Marker => { __p.word("Marker") }
Self::MayDangle(f0) => {
__p.word("MayDangle");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::MoveSizeLimit { limit } => {
__p.word("MoveSizeLimit");
if true && !limit.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if limit.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("limit");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
limit.print_attribute(__p);
__p.word("}");
}
Self::MustNotSuspend { reason } => {
__p.word("MustNotSuspend");
if true && !reason.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if reason.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reason");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reason.print_attribute(__p);
__p.word("}");
}
Self::MustUse { span, reason } => {
__p.word("MustUse");
if true && !span.should_render() && !reason.should_render()
{
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if reason.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reason");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reason.print_attribute(__p);
__p.word("}");
}
Self::Naked(f0) => {
__p.word("Naked");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::NeedsAllocator => { __p.word("NeedsAllocator") }
Self::NeedsPanicRuntime => { __p.word("NeedsPanicRuntime") }
Self::NoBuiltins => { __p.word("NoBuiltins") }
Self::NoCore => { __p.word("NoCore") }
Self::NoImplicitPrelude => { __p.word("NoImplicitPrelude") }
Self::NoLink => { __p.word("NoLink") }
Self::NoMain => { __p.word("NoMain") }
Self::NoMangle(f0) => {
__p.word("NoMangle");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::NoStd => { __p.word("NoStd") }
Self::NonExhaustive(f0) => {
__p.word("NonExhaustive");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::OnConst { span, directive } => {
__p.word("OnConst");
if true && !span.should_render() &&
!directive.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if directive.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("directive");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
directive.print_attribute(__p);
__p.word("}");
}
Self::OnMove { directive } => {
__p.word("OnMove");
if true && !directive.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if directive.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("directive");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
directive.print_attribute(__p);
__p.word("}");
}
Self::OnTypeError { span, directive } => {
__p.word("OnTypeError");
if true && !span.should_render() &&
!directive.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if directive.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("directive");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
directive.print_attribute(__p);
__p.word("}");
}
Self::OnUnimplemented { directive } => {
__p.word("OnUnimplemented");
if true && !directive.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if directive.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("directive");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
directive.print_attribute(__p);
__p.word("}");
}
Self::OnUnknown { directive } => {
__p.word("OnUnknown");
if true && !directive.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if directive.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("directive");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
directive.print_attribute(__p);
__p.word("}");
}
Self::OnUnmatchedArgs { directive } => {
__p.word("OnUnmatchedArgs");
if true && !directive.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if directive.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("directive");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
directive.print_attribute(__p);
__p.word("}");
}
Self::Opaque => { __p.word("Opaque") }
Self::Optimize(f0, f1) => {
__p.word("Optimize");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::PanicRuntime => { __p.word("PanicRuntime") }
Self::PatchableFunctionEntry { prefix, entry, section } => {
__p.word("PatchableFunctionEntry");
if true && !prefix.should_render() && !entry.should_render()
&& !section.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if prefix.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("prefix");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
prefix.print_attribute(__p);
if entry.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("entry");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
entry.print_attribute(__p);
if section.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("section");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
section.print_attribute(__p);
__p.word("}");
}
Self::Path(f0, f1) => {
__p.word("Path");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::PatternComplexityLimit { limit } => {
__p.word("PatternComplexityLimit");
if true && !limit.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if limit.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("limit");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
limit.print_attribute(__p);
__p.word("}");
}
Self::PinV2(f0) => {
__p.word("PinV2");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::PreludeImport => { __p.word("PreludeImport") }
Self::ProcMacro => { __p.word("ProcMacro") }
Self::ProcMacroAttribute => {
__p.word("ProcMacroAttribute")
}
Self::ProcMacroDerive { trait_name, helper_attrs } => {
__p.word("ProcMacroDerive");
if true && !trait_name.should_render() &&
!helper_attrs.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if trait_name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("trait_name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
trait_name.print_attribute(__p);
if helper_attrs.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("helper_attrs");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
helper_attrs.print_attribute(__p);
__p.word("}");
}
Self::ProfilerRuntime => { __p.word("ProfilerRuntime") }
Self::RecursionLimit { limit } => {
__p.word("RecursionLimit");
if true && !limit.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if limit.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("limit");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
limit.print_attribute(__p);
__p.word("}");
}
Self::ReexportTestHarnessMain(f0) => {
__p.word("ReexportTestHarnessMain");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RegisterTool { attr_tools, lint_tools } => {
__p.word("RegisterTool");
if true && !attr_tools.should_render() &&
!lint_tools.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if attr_tools.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_tools");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_tools.print_attribute(__p);
if lint_tools.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("lint_tools");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
lint_tools.print_attribute(__p);
__p.word("}");
}
Self::Repr { reprs, first_span } => {
__p.word("Repr");
if true && !reprs.should_render() &&
!first_span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if reprs.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reprs");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reprs.print_attribute(__p);
if first_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("first_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
first_span.print_attribute(__p);
__p.word("}");
}
Self::RustcAbi { attr_span, kind } => {
__p.word("RustcAbi");
if true && !attr_span.should_render() &&
!kind.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if attr_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_span.print_attribute(__p);
if kind.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("kind");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
kind.print_attribute(__p);
__p.word("}");
}
Self::RustcAlign { align, span } => {
__p.word("RustcAlign");
if true && !align.should_render() && !span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if align.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("align");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
align.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::RustcAllocator => { __p.word("RustcAllocator") }
Self::RustcAllocatorZeroed => {
__p.word("RustcAllocatorZeroed")
}
Self::RustcAllocatorZeroedVariant { name } => {
__p.word("RustcAllocatorZeroedVariant");
if true && !name.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
name.print_attribute(__p);
__p.word("}");
}
Self::RustcAllowConstFnUnstable(f0, f1) => {
__p.word("RustcAllowConstFnUnstable");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::RustcAllowIncoherentImpl(f0) => {
__p.word("RustcAllowIncoherentImpl");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcAllowLifetimeDependentSpecialization => {
__p.word("RustcAllowLifetimeDependentSpecialization")
}
Self::RustcAssertVariance { span, kind } => {
__p.word("RustcAssertVariance");
if true && !span.should_render() && !kind.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
if kind.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("kind");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
kind.print_attribute(__p);
__p.word("}");
}
Self::RustcAutodiff(f0) => {
__p.word("RustcAutodiff");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcBodyStability { stability, span } => {
__p.word("RustcBodyStability");
if true && !stability.should_render() &&
!span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if stability.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("stability");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
stability.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::RustcBuiltinMacro { builtin_name, helper_attrs } => {
__p.word("RustcBuiltinMacro");
if true && !builtin_name.should_render() &&
!helper_attrs.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if builtin_name.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("builtin_name");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
builtin_name.print_attribute(__p);
if helper_attrs.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("helper_attrs");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
helper_attrs.print_attribute(__p);
__p.word("}");
}
Self::RustcCanonicalSymbol => {
__p.word("RustcCanonicalSymbol")
}
Self::RustcCaptureAnalysis => {
__p.word("RustcCaptureAnalysis")
}
Self::RustcCguTestAttr(f0) => {
__p.word("RustcCguTestAttr");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcClean(f0) => {
__p.word("RustcClean");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcCoherenceIsCore => {
__p.word("RustcCoherenceIsCore")
}
Self::RustcCoinductive => { __p.word("RustcCoinductive") }
Self::RustcComptime(f0) => {
__p.word("RustcComptime");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcConfusables { confusables } => {
__p.word("RustcConfusables");
if true && !confusables.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if confusables.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("confusables");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
confusables.print_attribute(__p);
__p.word("}");
}
Self::RustcConstStability { stability, span } => {
__p.word("RustcConstStability");
if true && !stability.should_render() &&
!span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if stability.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("stability");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
stability.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::RustcConstStableIndirect => {
__p.word("RustcConstStableIndirect")
}
Self::RustcConversionSuggestion => {
__p.word("RustcConversionSuggestion")
}
Self::RustcDeallocator => { __p.word("RustcDeallocator") }
Self::RustcDelayedBugFromInsideQuery => {
__p.word("RustcDelayedBugFromInsideQuery")
}
Self::RustcDenyExplicitImpl => {
__p.word("RustcDenyExplicitImpl")
}
Self::RustcDeprecatedSafe2024 { suggestion } => {
__p.word("RustcDeprecatedSafe2024");
if true && !suggestion.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if suggestion.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("suggestion");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
suggestion.print_attribute(__p);
__p.word("}");
}
Self::RustcDiagnosticItem(f0) => {
__p.word("RustcDiagnosticItem");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcDoNotConstCheck => {
__p.word("RustcDoNotConstCheck")
}
Self::RustcDocPrimitive(f0, f1) => {
__p.word("RustcDocPrimitive");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::RustcDummy => { __p.word("RustcDummy") }
Self::RustcDumpClauses => { __p.word("RustcDumpClauses") }
Self::RustcDumpDefParents => {
__p.word("RustcDumpDefParents")
}
Self::RustcDumpDefPath(f0) => {
__p.word("RustcDumpDefPath");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcDumpGenerics => { __p.word("RustcDumpGenerics") }
Self::RustcDumpHiddenTypeOfOpaques => {
__p.word("RustcDumpHiddenTypeOfOpaques")
}
Self::RustcDumpInferredOutlives => {
__p.word("RustcDumpInferredOutlives")
}
Self::RustcDumpItemBounds => {
__p.word("RustcDumpItemBounds")
}
Self::RustcDumpLayout(f0) => {
__p.word("RustcDumpLayout");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcDumpObjectLifetimeDefaults => {
__p.word("RustcDumpObjectLifetimeDefaults")
}
Self::RustcDumpSymbolName(f0) => {
__p.word("RustcDumpSymbolName");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcDumpUserArgs => { __p.word("RustcDumpUserArgs") }
Self::RustcDumpVariances => {
__p.word("RustcDumpVariances")
}
Self::RustcDumpVariancesOfOpaques => {
__p.word("RustcDumpVariancesOfOpaques")
}
Self::RustcDumpVtable(f0) => {
__p.word("RustcDumpVtable");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcDynIncompatibleTrait(f0) => {
__p.word("RustcDynIncompatibleTrait");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcEffectiveVisibility => {
__p.word("RustcEffectiveVisibility")
}
Self::RustcEiiForeignItem => {
__p.word("RustcEiiForeignItem")
}
Self::RustcEvaluateWhereClauses => {
__p.word("RustcEvaluateWhereClauses")
}
Self::RustcHasIncoherentInherentImpls => {
__p.word("RustcHasIncoherentInherentImpls")
}
Self::RustcIfThisChanged(f0, f1) => {
__p.word("RustcIfThisChanged");
if true && !f0.should_render() && !f1.should_render() {
return;
}
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
if f1.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f1.print_attribute(__p);
__p.pclose();
}
Self::RustcInheritOverflowChecks => {
__p.word("RustcInheritOverflowChecks")
}
Self::RustcInsignificantDtor => {
__p.word("RustcInsignificantDtor")
}
Self::RustcIntrinsic { llvm } => {
__p.word("RustcIntrinsic");
if true && !llvm.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if llvm.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("llvm");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
llvm.print_attribute(__p);
__p.word("}");
}
Self::RustcIntrinsicConstStableIndirect => {
__p.word("RustcIntrinsicConstStableIndirect")
}
Self::RustcLegacyConstGenerics { fn_indexes, attr_span } =>
{
__p.word("RustcLegacyConstGenerics");
if true && !fn_indexes.should_render() &&
!attr_span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if fn_indexes.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("fn_indexes");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
fn_indexes.print_attribute(__p);
if attr_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_span.print_attribute(__p);
__p.word("}");
}
Self::RustcLintOptDenyFieldAccess { lint_message } => {
__p.word("RustcLintOptDenyFieldAccess");
if true && !lint_message.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if lint_message.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("lint_message");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
lint_message.print_attribute(__p);
__p.word("}");
}
Self::RustcLintOptTy => { __p.word("RustcLintOptTy") }
Self::RustcLintQueryInstability => {
__p.word("RustcLintQueryInstability")
}
Self::RustcLintUntrackedQueryInformation => {
__p.word("RustcLintUntrackedQueryInformation")
}
Self::RustcMacroTransparency(f0) => {
__p.word("RustcMacroTransparency");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcMain => { __p.word("RustcMain") }
Self::RustcMir(f0) => {
__p.word("RustcMir");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcMustImplementOneOf { attr_span, fn_names } => {
__p.word("RustcMustImplementOneOf");
if true && !attr_span.should_render() &&
!fn_names.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if attr_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_span.print_attribute(__p);
if fn_names.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("fn_names");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
fn_names.print_attribute(__p);
__p.word("}");
}
Self::RustcMustMatchExhaustively(f0) => {
__p.word("RustcMustMatchExhaustively");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcNoImplicitAutorefs => {
__p.word("RustcNoImplicitAutorefs")
}
Self::RustcNoImplicitBounds => {
__p.word("RustcNoImplicitBounds")
}
Self::RustcNoMirInline => { __p.word("RustcNoMirInline") }
Self::RustcNoWritable => { __p.word("RustcNoWritable") }
Self::RustcNonConstTraitMethod => {
__p.word("RustcNonConstTraitMethod")
}
Self::RustcNonnullOptimizationGuaranteed => {
__p.word("RustcNonnullOptimizationGuaranteed")
}
Self::RustcNounwind => { __p.word("RustcNounwind") }
Self::RustcObjcClass { classname } => {
__p.word("RustcObjcClass");
if true && !classname.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if classname.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("classname");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
classname.print_attribute(__p);
__p.word("}");
}
Self::RustcObjcSelector { methname } => {
__p.word("RustcObjcSelector");
if true && !methname.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if methname.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("methname");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
methname.print_attribute(__p);
__p.word("}");
}
Self::RustcOffloadKernel => {
__p.word("RustcOffloadKernel")
}
Self::RustcPanicsWhenZero => {
__p.word("RustcPanicsWhenZero")
}
Self::RustcParenSugar => { __p.word("RustcParenSugar") }
Self::RustcPassByValue => { __p.word("RustcPassByValue") }
Self::RustcPassIndirectlyInNonRusticAbis(f0) => {
__p.word("RustcPassIndirectlyInNonRusticAbis");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcPreserveUbChecks => {
__p.word("RustcPreserveUbChecks")
}
Self::RustcProcMacroDecls => {
__p.word("RustcProcMacroDecls")
}
Self::RustcPubTransparent(f0) => {
__p.word("RustcPubTransparent");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcReallocator => { __p.word("RustcReallocator") }
Self::RustcRegions => { __p.word("RustcRegions") }
Self::RustcScalableVector { element_count } => {
__p.word("RustcScalableVector");
if true && !element_count.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if element_count.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("element_count");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
element_count.print_attribute(__p);
__p.word("}");
}
Self::RustcShowSpans(f0) => {
__p.word("RustcShowSpans");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcSimdMonomorphizeLaneLimit(f0) => {
__p.word("RustcSimdMonomorphizeLaneLimit");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcSkipDuringMethodDispatch { array, boxed_slice }
=> {
__p.word("RustcSkipDuringMethodDispatch");
if true && !array.should_render() &&
!boxed_slice.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if array.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("array");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
array.print_attribute(__p);
if boxed_slice.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("boxed_slice");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
boxed_slice.print_attribute(__p);
__p.word("}");
}
Self::RustcSpecializationTrait => {
__p.word("RustcSpecializationTrait")
}
Self::RustcStdInternalSymbol => {
__p.word("RustcStdInternalSymbol")
}
Self::RustcStrictCoherence(f0) => {
__p.word("RustcStrictCoherence");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcTestEntrypointMarker => {
__p.word("RustcTestEntrypointMarker")
}
Self::RustcTestMarker(f0) => {
__p.word("RustcTestMarker");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcThenThisWouldNeed(f0) => {
__p.word("RustcThenThisWouldNeed");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::RustcTrivialFieldReads(f0) => {
__p.word("RustcTrivialFieldReads");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Sanitize { on_set, off_set, rtsan, span } => {
__p.word("Sanitize");
if true && !on_set.should_render() &&
!off_set.should_render() && !rtsan.should_render() &&
!span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if on_set.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("on_set");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
on_set.print_attribute(__p);
if off_set.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("off_set");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
off_set.print_attribute(__p);
if rtsan.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("rtsan");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
rtsan.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::ShouldPanic { reason } => {
__p.word("ShouldPanic");
if true && !reason.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if reason.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("reason");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
reason.print_attribute(__p);
__p.word("}");
}
Self::Splat(f0) => {
__p.word("Splat");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Stability { stability, span } => {
__p.word("Stability");
if true && !stability.should_render() &&
!span.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if stability.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("stability");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
stability.print_attribute(__p);
if span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
span.print_attribute(__p);
__p.word("}");
}
Self::TargetFeature { features, attr_span, was_forced } => {
__p.word("TargetFeature");
if true && !features.should_render() &&
!attr_span.should_render() && !was_forced.should_render() {
return;
}
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if features.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("features");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
features.print_attribute(__p);
if attr_span.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("attr_span");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
attr_span.print_attribute(__p);
if was_forced.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("was_forced");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
was_forced.print_attribute(__p);
__p.word("}");
}
Self::TestRunner(f0) => {
__p.word("TestRunner");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::ThreadLocal => { __p.word("ThreadLocal") }
Self::TrackCaller(f0) => {
__p.word("TrackCaller");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::TypeLengthLimit { limit } => {
__p.word("TypeLengthLimit");
if true && !limit.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if limit.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("limit");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
limit.print_attribute(__p);
__p.word("}");
}
Self::UncheckedTypeAlias => {
__p.word("UncheckedTypeAlias")
}
Self::Unroll(f0) => {
__p.word("Unroll");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::UnstableFeatureBound(f0) => {
__p.word("UnstableFeatureBound");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::UnstableRemoved(f0) => {
__p.word("UnstableRemoved");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
Self::Used { used_by } => {
__p.word("Used");
if true && !used_by.should_render() { return; }
__p.nbsp();
__p.word("{");
let mut __printed_anything = false;
if used_by.should_render() {
if __printed_anything { __p.word_space(","); }
__p.word("used_by");
__p.word(":");
__p.nbsp();
__printed_anything = true;
}
used_by.print_attribute(__p);
__p.word("}");
}
Self::WindowsSubsystem(f0) => {
__p.word("WindowsSubsystem");
if true && !f0.should_render() { return; }
__p.popen();
let mut __printed_anything = false;
if f0.should_render() {
if __printed_anything { __p.word_space(","); }
__printed_anything = true;
}
f0.print_attribute(__p);
__p.pclose();
}
}
}
}
};PrintAttribute)]
828pub enum AttributeKind {
829 AllowInternalUnsafe(Span),
832
833 AllowInternalUnstable(ThinVec<(Symbol, Span)>, Span),
835
836 AlwaysGca,
838
839 AutomaticallyDerived,
841
842 CfgAttrTrace(ThinVec<(CfgEntry, Span)>),
844
845 CfgTrace(ThinVec<(CfgEntry, Span)>),
847
848 CfiEncoding {
850 encoding: Symbol,
851 },
852
853 Cold,
855
856 CollapseDebugInfo(CollapseMacroDebuginfo),
858
859 CompilerBuiltins,
861
862 ConstContinue(Span),
864
865 Coroutine,
869
870 Coverage(CoverageAttrKind),
872
873 CrateName {
875 name: Symbol,
876 name_span: Span,
877 attr_span: Span,
878 },
879
880 CrateType(ThinVec<CrateType>),
882
883 CustomMir(Option<(MirDialect, Span)>, Option<(MirPhase, Span)>),
885
886 DebuggerVisualizer(ThinVec<DebugVisualizer>),
888
889 DefaultLibAllocator,
891
892 Deprecated {
894 deprecation: Deprecation,
895 span: Span,
896 is_inner: bool,
898 },
899
900 DoNotRecommend,
902
903 Doc(Box<DocAttribute>),
907
908 DocComment {
911 style: AttrStyle,
912 kind: DocFragmentKind,
913 span: Span,
914 comment: Symbol,
915 },
916
917 EiiDeclaration(EiiDecl),
919
920 EiiImpl(Box<EiiImpl>),
922
923 ExportName {
925 name: Symbol,
928 span: Span,
929 },
930
931 ExportStable,
933
934 Feature(ThinVec<Ident>, Span),
936
937 FfiConst,
939
940 FfiPure(Span),
942
943 Fundamental,
945
946 Ignore {
948 span: Span,
949 reason: Option<Symbol>,
951 },
952
953 Inline(InlineAttr, Span),
955
956 InstructionSet(InstructionSetAttr),
958
959 InstrumentFn(InstrumentFnAttr),
961
962 Lang(LangItem),
964
965 Link(ThinVec<LinkEntry>, Span),
967
968 LinkName {
970 name: Symbol,
971 span: Span,
972 },
973
974 LinkOrdinal {
976 ordinal: u16,
977 span: Span,
978 },
979
980 LinkSection {
982 name: Symbol,
983 },
984
985 Linkage(Linkage, Span),
987
988 LintAsPtr,
990
991 LintCheck(ThinVec<LintCheck>),
993
994 LintNeverReturnsNullPtr,
996
997 LintShouldNotBeCalledOnConstItems,
1000
1001 LoopMatch(Span),
1003
1004 MacroEscape,
1006
1007 MacroExport {
1009 span: Span,
1010 local_inner_macros: bool,
1011 },
1012
1013 MacroUse {
1015 span: Span,
1016 arguments: MacroUseArgs,
1017 },
1018
1019 Marker,
1021
1022 MayDangle(Span),
1024
1025 MoveSizeLimit {
1027 limit: Limit,
1028 },
1029
1030 MustNotSuspend {
1032 reason: Option<Symbol>,
1033 },
1034
1035 MustUse {
1037 span: Span,
1039 reason: Option<Symbol>,
1041 },
1042
1043 Naked(Span),
1045
1046 NeedsAllocator,
1048
1049 NeedsPanicRuntime,
1051
1052 NoBuiltins,
1054
1055 NoCore,
1057
1058 NoImplicitPrelude,
1060
1061 NoLink,
1063
1064 NoMain,
1066
1067 NoMangle(Span),
1069
1070 NoStd,
1072
1073 NonExhaustive(Span),
1075
1076 OnConst {
1078 span: Span,
1080 directive: Option<Box<Directive>>,
1082 },
1083
1084 OnMove {
1086 directive: Option<Box<Directive>>,
1087 },
1088
1089 OnTypeError {
1091 span: Span,
1092 directive: Option<Box<Directive>>,
1093 },
1094
1095 OnUnimplemented {
1097 directive: Option<Box<Directive>>,
1099 },
1100
1101 OnUnknown {
1103 directive: Option<Box<Directive>>,
1105 },
1106
1107 OnUnmatchedArgs {
1109 directive: Option<Box<Directive>>,
1111 },
1112
1113 Opaque,
1115
1116 Optimize(OptimizeAttr, Span),
1118
1119 PanicRuntime,
1121
1122 PatchableFunctionEntry {
1124 prefix: Option<u8>,
1125 entry: Option<u8>,
1126 section: Option<Symbol>,
1127 },
1128
1129 Path(Symbol, Span),
1131
1132 PatternComplexityLimit {
1134 limit: Limit,
1135 },
1136
1137 PinV2(Span),
1142
1143 PreludeImport,
1145
1146 ProcMacro,
1148
1149 ProcMacroAttribute,
1151
1152 ProcMacroDerive {
1154 trait_name: Symbol,
1155 helper_attrs: ThinVec<Symbol>,
1156 },
1157
1158 ProfilerRuntime,
1160
1161 RecursionLimit {
1163 limit: Limit,
1164 },
1165
1166 ReexportTestHarnessMain(Symbol),
1168
1169 RegisterTool {
1171 attr_tools: ThinVec<(Ident, ToolOptions)>,
1172 lint_tools: ThinVec<(Ident, ToolOptions)>,
1173 },
1174
1175 Repr {
1177 reprs: ThinVec<(ReprAttr, Span)>,
1178 first_span: Span,
1179 },
1180
1181 RustcAbi {
1183 attr_span: Span,
1184 kind: RustcAbiAttrKind,
1185 },
1186
1187 RustcAlign {
1191 align: Align,
1192 span: Span,
1193 },
1194
1195 RustcAllocator,
1197
1198 RustcAllocatorZeroed,
1200
1201 RustcAllocatorZeroedVariant {
1203 name: Symbol,
1204 },
1205
1206 RustcAllowConstFnUnstable(ThinVec<Symbol>, Span),
1208
1209 RustcAllowIncoherentImpl(Span),
1211
1212 RustcAllowLifetimeDependentSpecialization,
1214
1215 RustcAssertVariance {
1217 span: Span,
1218 kind: RustcAssertVarianceKind,
1219 },
1220
1221 RustcAutodiff(Option<Box<RustcAutodiff>>),
1223
1224 RustcBodyStability {
1226 stability: DefaultBodyStability,
1227 span: Span,
1229 },
1230 RustcBuiltinMacro {
1232 builtin_name: Option<Symbol>,
1233 helper_attrs: ThinVec<Symbol>,
1234 },
1235
1236 RustcCanonicalSymbol,
1238
1239 RustcCaptureAnalysis,
1241
1242 RustcCguTestAttr(ThinVec<(Span, CguFields)>),
1244
1245 RustcClean(ThinVec<RustcCleanAttribute>),
1247
1248 RustcCoherenceIsCore,
1250
1251 RustcCoinductive,
1253
1254 RustcComptime(Span),
1256
1257 RustcConfusables {
1259 confusables: ThinVec<Symbol>,
1260 },
1261 RustcConstStability {
1263 stability: PartialConstStability,
1264 span: Span,
1267 },
1268
1269 RustcConstStableIndirect,
1271
1272 RustcConversionSuggestion,
1276
1277 RustcDeallocator,
1279
1280 RustcDelayedBugFromInsideQuery,
1282
1283 RustcDenyExplicitImpl,
1285
1286 RustcDeprecatedSafe2024 {
1288 suggestion: Symbol,
1289 },
1290 RustcDiagnosticItem(Symbol),
1292
1293 RustcDoNotConstCheck,
1298
1299 RustcDocPrimitive(Span, Symbol),
1301
1302 RustcDummy,
1304
1305 RustcDumpClauses,
1307
1308 RustcDumpDefParents,
1310
1311 RustcDumpDefPath(Span),
1313
1314 RustcDumpGenerics,
1316
1317 RustcDumpHiddenTypeOfOpaques,
1319
1320 RustcDumpInferredOutlives,
1322
1323 RustcDumpItemBounds,
1325
1326 RustcDumpLayout(ThinVec<RustcDumpLayoutKind>),
1328
1329 RustcDumpObjectLifetimeDefaults,
1331
1332 RustcDumpSymbolName(Span),
1334
1335 RustcDumpUserArgs,
1337
1338 RustcDumpVariances,
1340
1341 RustcDumpVariancesOfOpaques,
1343
1344 RustcDumpVtable(Span),
1346
1347 RustcDynIncompatibleTrait(Span),
1349
1350 RustcEffectiveVisibility,
1352
1353 RustcEiiForeignItem,
1355
1356 RustcEvaluateWhereClauses,
1358
1359 RustcHasIncoherentInherentImpls,
1360
1361 RustcIfThisChanged(Span, Option<Symbol>),
1363
1364 RustcInheritOverflowChecks,
1366
1367 RustcInsignificantDtor,
1369
1370 RustcIntrinsic {
1372 llvm: Option<Symbol>,
1373 },
1374
1375 RustcIntrinsicConstStableIndirect,
1377
1378 RustcLegacyConstGenerics {
1380 fn_indexes: ThinVec<(usize, Span)>,
1381 attr_span: Span,
1382 },
1383
1384 RustcLintOptDenyFieldAccess {
1389 lint_message: Symbol,
1390 },
1391
1392 RustcLintOptTy,
1397
1398 RustcLintQueryInstability,
1403
1404 RustcLintUntrackedQueryInformation,
1409
1410 RustcMacroTransparency(Transparency),
1412
1413 RustcMain,
1415
1416 RustcMir(ThinVec<RustcMirKind>),
1418
1419 RustcMustImplementOneOf {
1421 attr_span: Span,
1422 fn_names: ThinVec<Ident>,
1423 },
1424
1425 RustcMustMatchExhaustively(Span),
1427
1428 RustcNoImplicitAutorefs,
1430
1431 RustcNoImplicitBounds,
1433
1434 RustcNoMirInline,
1436
1437 RustcNoWritable,
1439
1440 RustcNonConstTraitMethod,
1442
1443 RustcNonnullOptimizationGuaranteed,
1445
1446 RustcNounwind,
1448
1449 RustcObjcClass {
1451 classname: Symbol,
1452 },
1453
1454 RustcObjcSelector {
1456 methname: Symbol,
1457 },
1458
1459 RustcOffloadKernel,
1461
1462 RustcPanicsWhenZero,
1464
1465 RustcParenSugar,
1467
1468 RustcPassByValue,
1470
1471 RustcPassIndirectlyInNonRusticAbis(Span),
1475
1476 RustcPreserveUbChecks,
1478
1479 RustcProcMacroDecls,
1481
1482 RustcPubTransparent(Span),
1485
1486 RustcReallocator,
1488
1489 RustcRegions,
1491
1492 RustcScalableVector {
1494 element_count: Option<u16>,
1497 },
1498
1499 RustcShowSpans(ThinVec<RustcShowSpansKind>),
1501
1502 RustcSimdMonomorphizeLaneLimit(Limit),
1504
1505 RustcSkipDuringMethodDispatch {
1507 array: bool,
1508 boxed_slice: bool,
1509 },
1510
1511 RustcSpecializationTrait,
1513
1514 RustcStdInternalSymbol,
1516
1517 RustcStrictCoherence(Span),
1519
1520 RustcTestEntrypointMarker,
1522
1523 RustcTestMarker(Symbol),
1525
1526 RustcThenThisWouldNeed(ThinVec<Ident>),
1528
1529 RustcTrivialFieldReads(Span),
1531
1532 Sanitize {
1538 on_set: SanitizerSet,
1539 off_set: SanitizerSet,
1540 rtsan: Option<RtsanSetting>,
1541 span: Span,
1542 },
1543
1544 ShouldPanic {
1546 reason: Option<Symbol>,
1547 },
1548
1549 Splat(Span),
1555
1556 Stability {
1558 stability: Stability,
1559 span: Span,
1561 },
1562
1563 TargetFeature {
1566 features: ThinVec<(Symbol, Span)>,
1567 attr_span: Span,
1568 was_forced: bool,
1569 },
1570
1571 TestRunner(Path),
1573
1574 ThreadLocal,
1576
1577 TrackCaller(Span),
1579
1580 TypeLengthLimit {
1582 limit: Limit,
1583 },
1584
1585 UncheckedTypeAlias,
1588
1589 Unroll(UnrollAttr),
1595
1596 UnstableFeatureBound(ThinVec<(Symbol, Span)>),
1598
1599 UnstableRemoved(ThinVec<UnstableRemovedFeature>),
1601
1602 Used {
1604 used_by: UsedBy,
1605 },
1606
1607 WindowsSubsystem(WindowsSubsystemKind),
1609 }