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_macros::{
16 Decodable, Decodable_NoContext, Encodable, Encodable_NoContext, PrintAttribute, StableHash,
17};
18use rustc_span::def_id::DefId;
19use rustc_span::hygiene::Transparency;
20use rustc_span::{ErrorGuaranteed, Ident, Span, Symbol};
21use rustc_structures::{CollapseMacroDebuginfo, CrateType, Limit, NativeLibKind, SanitizerSet};
22use thin_vec::ThinVec;
23
24pub use crate::canonical_symbols::{CanonicalSymbol, CanonicalSymbols};
25use crate::diagnostic::*;
26use crate::lang_items::LangItem;
27use crate::lint::LintCheck;
28use crate::pretty_printing::PrintAttribute;
29use crate::stability::{DefaultBodyStability, PartialConstStability, Stability};
30
31#[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]
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]
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)]
32pub enum EiiImplResolution {
33 Macro(DefId),
37 Known(DefId),
40 Error(ErrorGuaranteed),
42}
43
44#[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]
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]
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)]
45pub struct EiiImpl {
46 pub resolution: EiiImplResolution,
47 pub impl_unsafe_span: Option<Span>,
48 pub span: Span,
49 pub inner_span: Span,
50 pub is_default: bool,
51}
52
53#[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]
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]
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)]
54pub struct EiiDecl {
55 pub foreign_item: DefId,
56 pub impl_unsafe: bool,
58 pub name: Ident,
59}
60
61#[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]
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]
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)]
62pub enum CguKind {
63 No,
64 PreDashLto,
65 PostDashLto,
66 Any,
67}
68
69#[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]
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]
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)]
70pub enum CguFields {
71 PartitionReused { cfg: Symbol, module: Symbol },
72 PartitionCodegened { cfg: Symbol, module: Symbol },
73 ExpectedCguReuse { cfg: Symbol, module: Symbol, kind: CguKind },
74}
75
76#[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]
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]
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)]
77pub enum InlineAttr {
78 None,
79 Hint,
80 Always,
81 Never,
82 Force {
86 attr_span: Span,
87 reason: Option<Symbol>,
88 },
89}
90
91impl InlineAttr {
92 pub fn always(&self) -> bool {
93 match self {
94 InlineAttr::Always | InlineAttr::Force { .. } => true,
95 InlineAttr::None | InlineAttr::Hint | InlineAttr::Never => false,
96 }
97 }
98}
99
100#[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]
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]
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)]
101pub enum UnrollAttr {
102 Hint,
103 Full,
104 Never,
105 Count(u32),
106}
107
108#[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]
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]
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)]
109pub enum InstructionSetAttr {
110 ArmA32,
111 ArmT32,
112}
113
114#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for InstrumentFnAttr {
#[inline]
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)]
115#[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)]
116pub enum InstrumentFnAttr {
117 On,
119 Off,
121}
122
123#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for OptimizeAttr {
#[inline]
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)]
124#[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)]
125pub enum OptimizeAttr {
126 #[default]
128 Default,
129 DoNotOptimize,
131 Speed,
133 Size,
135}
136
137impl OptimizeAttr {
138 pub fn do_not_optimize(&self) -> bool {
139 #[allow(non_exhaustive_omitted_patterns)] match self {
Self::DoNotOptimize => true,
_ => false,
}matches!(self, Self::DoNotOptimize)
140 }
141}
142
143#[derive(
144 #[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,
145 #[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,
146 #[automatically_derived]impl ::core::fmt::Debug for ReprAttr {
#[inline]
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,
147 #[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,
148 #[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,
149 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,
150 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,
151 #[automatically_derived]impl ::core::marker::Copy for ReprAttr { }Copy,
152 #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for ReprAttr {
}
#[automatically_derived]impl ::core::clone::Clone for ReprAttr {
#[inline]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<IntType>;
let _: ::core::clone::AssertParamIsClone<Align>;
*self
}
}Clone,
153 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,
154 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
155)]
156pub enum ReprAttr {
157 ReprInt(IntType),
158 ReprRust,
159 ReprC,
160 ReprPacked(Align),
161 ReprSimd,
162 ReprTransparent,
163 ReprAlign(Align),
164}
165
166#[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]
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]
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)]
167#[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)]
168pub enum IntType {
169 SignedInt(ast::IntTy),
170 UnsignedInt(ast::UintTy),
171}
172
173#[derive(#[automatically_derived]impl ::core::marker::Copy for Deprecation { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Deprecation {
#[inline]
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]
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)]
174pub struct Deprecation {
175 pub since: DeprecatedSince,
176 pub note: Option<Ident>,
178 pub suggestion: Option<Symbol>,
182}
183
184#[derive(#[automatically_derived]impl ::core::marker::Copy for DeprecatedSince { }Copy, #[automatically_derived]impl ::core::fmt::Debug for DeprecatedSince {
#[inline]
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]
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)]
186pub enum DeprecatedSince {
187 RustcVersion(RustcVersion),
188 Future,
190 NonStandard(Symbol),
193 Unspecified,
195 Err,
198}
199
200#[derive(#[automatically_derived]impl ::core::marker::Copy for CoverageAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for CoverageAttrKind {
#[inline]
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]
fn clone(&self) -> Self { *self }
}Clone)]
202#[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)]
203pub enum CoverageAttrKind {
204 On,
205 Off,
206}
207
208#[derive(#[automatically_derived]impl ::core::marker::Copy for RustcAbiAttrKind { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RustcAbiAttrKind {
#[inline]
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]
fn clone(&self) -> Self { *self }
}Clone)]
210#[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)]
211pub enum RustcAbiAttrKind {
212 Debug,
213 AssertEq,
214}
215
216impl Deprecation {
217 pub fn is_in_effect(&self) -> bool {
221 match self.since {
222 DeprecatedSince::RustcVersion(since) => since <= RustcVersion::CURRENT,
223 DeprecatedSince::Future => false,
224 DeprecatedSince::NonStandard(_) => true,
226 DeprecatedSince::Unspecified | DeprecatedSince::Err => true,
228 }
229 }
230
231 pub fn is_since_rustc_version(&self) -> bool {
232 #[allow(non_exhaustive_omitted_patterns)] match self.since {
DeprecatedSince::RustcVersion(_) => true,
_ => false,
}matches!(self.since, DeprecatedSince::RustcVersion(_))
233 }
234}
235
236#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for UsedBy {
#[inline]
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)]
241#[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)]
242pub enum UsedBy {
243 Default,
244 Compiler,
245 Linker,
246}
247
248#[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]
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]
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)]
249#[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)]
250pub enum MacroUseArgs {
251 UseAll,
252 UseSpecific(ThinVec<Ident>),
253}
254
255impl Default for MacroUseArgs {
256 fn default() -> Self {
257 Self::UseSpecific(ThinVec::new())
258 }
259}
260
261#[derive(#[automatically_derived]impl<ScopeId: ::core::fmt::Debug> ::core::fmt::Debug
for StrippedCfgItem<ScopeId> {
#[inline]
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]
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)]
262pub struct StrippedCfgItem<ScopeId = DefId> {
263 pub parent_scope: ScopeId,
264 pub ident: Ident,
265 pub cfg: (CfgEntry, Span),
266}
267
268impl<ScopeId> StrippedCfgItem<ScopeId> {
269 pub fn map_scope_id<New>(self, f: impl FnOnce(ScopeId) -> New) -> StrippedCfgItem<New> {
270 StrippedCfgItem { parent_scope: f(self.parent_scope), ident: self.ident, cfg: self.cfg }
271 }
272}
273
274#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for Linkage { }Copy, #[automatically_derived]impl ::core::fmt::Debug for Linkage {
#[inline]
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)]
279#[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)]
280pub enum Linkage {
281 AvailableExternally,
282 ExternalWeak,
283 External,
284 Internal,
285 LinkOnceAny,
286 LinkOnceODR,
287 WeakAny,
288 WeakODR,
289}
290
291#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for MirDialect {
}
#[automatically_derived]impl ::core::clone::Clone for MirDialect {
#[inline]
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]
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)]
292#[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)]
293pub enum MirDialect {
294 Analysis,
295 Built,
296 Runtime,
297}
298
299impl IntoDiagArg for MirDialect {
300 fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
301 let arg = match self {
302 MirDialect::Analysis => "analysis",
303 MirDialect::Built => "built",
304 MirDialect::Runtime => "runtime",
305 };
306 DiagArgValue::Str(Cow::Borrowed(arg))
307 }
308}
309
310#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for MirPhase {
}
#[automatically_derived]impl ::core::clone::Clone for MirPhase {
#[inline]
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]
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)]
311#[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)]
312pub enum MirPhase {
313 Initial,
314 PostCleanup,
315 Optimized,
316}
317
318impl IntoDiagArg for MirPhase {
319 fn into_diag_arg(self, _path: &mut Option<PathBuf>) -> DiagArgValue {
320 let arg = match self {
321 MirPhase::Initial => "initial",
322 MirPhase::PostCleanup => "post-cleanup",
323 MirPhase::Optimized => "optimized",
324 };
325 DiagArgValue::Str(Cow::Borrowed(arg))
326 }
327}
328
329#[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]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<u16>;
*self
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for PeImportNameType {
#[inline]
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)]
332pub enum PeImportNameType {
333 Ordinal(u16),
336 Decorated,
339 NoPrefix,
342 Undecorated,
346}
347
348#[derive(#[automatically_derived]impl ::core::fmt::Debug for LinkEntry {
#[inline]
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]
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)]
349pub struct LinkEntry {
350 pub span: Span,
351 pub kind: NativeLibKind,
352 pub name: Symbol,
353 pub cfg: Option<CfgEntry>,
354 pub verbatim: Option<bool>,
355 pub import_name_type: Option<(PeImportNameType, Span)>,
356}
357
358#[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)]
359#[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]
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]
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)]
360pub enum DebuggerVisualizerType {
361 Natvis,
362 GdbPrettyPrinter,
363}
364
365#[derive(#[automatically_derived]impl ::core::fmt::Debug for DebugVisualizer {
#[inline]
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]
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)]
366pub struct DebugVisualizer {
367 pub span: Span,
368 pub visualizer_type: DebuggerVisualizerType,
369 pub path: Symbol,
370}
371
372#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for RtsanSetting {
}
#[automatically_derived]impl ::core::clone::Clone for RtsanSetting {
#[inline]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for RtsanSetting { }Copy, #[automatically_derived]impl ::core::fmt::Debug for RtsanSetting {
#[inline]
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)]
373#[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)]
374#[derive_const(#[automatically_derived]const impl ::core::default::Default for RtsanSetting {
#[inline]
fn default() -> Self { Self::Caller }
}Default)]
375pub enum RtsanSetting {
376 Nonblocking,
377 Blocking,
378 #[default]
379 Caller,
380}
381
382#[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]
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]
fn clone(&self) -> Self { *self }
}Clone)]
383#[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)]
384pub enum WindowsSubsystemKind {
385 Console,
386 Windows,
387}
388
389impl WindowsSubsystemKind {
390 pub fn as_str(&self) -> &'static str {
391 match self {
392 WindowsSubsystemKind::Console => "console",
393 WindowsSubsystemKind::Windows => "windows",
394 }
395 }
396}
397
398#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for DocInline {
#[inline]
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)]
399#[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)]
400pub enum DocInline {
401 Inline,
402 NoInline,
403}
404
405#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for HideOrShow {
#[inline]
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)]
406#[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)]
407pub enum HideOrShow {
408 Hide,
409 Show,
410}
411
412#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for DocCfgHideShowValue {
}
#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShowValue {
#[inline]
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]
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)]
413pub struct DocCfgHideShowValue {
414 pub span: Span,
415 pub value: Option<Symbol>,
417}
418
419impl DocCfgHideShowValue {
420 pub fn new(value: Symbol, span: Span) -> Self {
421 Self { span, value: Some(value) }
422 }
423
424 pub fn new_none(span: Span) -> Self {
425 Self { span, value: None }
426 }
427}
428
429#[derive(#[automatically_derived]impl ::core::clone::Clone for DocCfgHideShow {
#[inline]
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]
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)]
430pub enum DocCfgHideShow {
431 Any(Span),
432 List(ThinVec<DocCfgHideShowValue>),
433}
434
435impl DocCfgHideShow {
436 pub fn new() -> Self {
437 Self::List(ThinVec::new())
438 }
439
440 pub fn new_with_only_key(span: Span) -> Self {
441 let mut values = ThinVec::with_capacity(1);
442 values.push(DocCfgHideShowValue { span, value: None });
443 Self::List(values)
444 }
445
446 pub fn push_none(&mut self, span: Span) {
447 if let Self::List(values) = self
448 && !values.iter().any(|v| v.value.is_none())
449 {
450 values.push(DocCfgHideShowValue { span, value: None });
451 }
452 }
453
454 pub fn merge_with(&mut self, other: &Self) {
455 match (self, other) {
456 (Self::Any(_), Self::Any(_) | Self::List(_)) => {
457 }
459 (s, Self::Any(span)) => {
460 *s = Self::Any(*span);
462 }
463 (Self::List(values), Self::List(other_values)) => {
464 for other in other_values {
467 if !values.iter().any(|value| value.value == other.value) {
468 values.push(*other);
469 }
470 }
471 }
472 }
473 }
474}
475
476#[derive(#[automatically_derived]impl ::core::clone::Clone for CfgHideShow {
#[inline]
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]
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)]
477pub struct CfgHideShow {
478 pub kind: HideOrShow,
479 pub values: FxIndexMap<Symbol, DocCfgHideShow>,
480}
481
482#[derive(#[automatically_derived]impl ::core::clone::Clone for DocAttribute {
#[inline]
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]
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)]
483pub struct DocAttribute {
484 pub first_span: Span,
485
486 pub aliases: FxIndexMap<Symbol, Span>,
487 pub hidden: Option<Span>,
488 pub inline: Option<(DocInline, Span)>,
489
490 pub cfg: ThinVec<CfgEntry>,
492 pub auto_cfg: ThinVec<(CfgHideShow, Span)>,
493 pub auto_cfg_change: ThinVec<(bool, Span)>,
495
496 pub fake_variadic: Option<Span>,
498 pub keyword: Option<(Symbol, Span)>,
499 pub attribute: Option<(Symbol, Span)>,
500 pub masked: Option<Span>,
501 pub notable_trait: Option<(Option<(NotableTraitColor, Span)>, Span)>,
502 pub search_unbox: Option<Span>,
503
504 pub html_favicon_url: Option<(Symbol, Span)>,
506 pub html_logo_url: Option<(Symbol, Span)>,
507 pub html_playground_url: Option<(Symbol, Span)>,
508 pub html_root_url: Option<(Symbol, Span)>,
509 pub html_no_source: Option<Span>,
510 pub issue_tracker_base_url: Option<(Symbol, Span)>,
511 pub rust_logo: Option<Span>,
512
513 pub test_attrs: ThinVec<Span>,
515 pub no_crate_inject: Option<Span>,
516}
517
518#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for NotableTraitColor {
}
#[automatically_derived]impl ::core::clone::Clone for NotableTraitColor {
#[inline]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::marker::Copy for NotableTraitColor { }Copy, #[automatically_derived]impl ::core::fmt::Debug for NotableTraitColor {
#[inline]
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)]
519#[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)]
520pub enum NotableTraitColor {
521 Grey,
522 Red,
523 Green,
524 Yellow,
525 Blue,
526 Magenta,
527 Cyan,
528 Transparent,
529}
530
531impl From<NotableTraitColor> for &'static str {
532 fn from(color: NotableTraitColor) -> &'static str {
533 use NotableTraitColor::*;
534 match color {
535 Grey => "grey",
536 Red => "red",
537 Green => "green",
538 Yellow => "yellow",
539 Blue => "blue",
540 Magenta => "magenta",
541 Cyan => "cyan",
542 Transparent => "transparent",
543 }
544 }
545}
546
547impl std::fmt::Display for NotableTraitColor {
548 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
549 f.write_str((*self).into())
550 }
551}
552
553impl<E: rustc_span::SpanEncoder> rustc_serialize::Encodable<E> for DocAttribute {
554 fn encode(&self, encoder: &mut E) {
555 let DocAttribute {
556 first_span,
557 aliases,
558 hidden,
559 inline,
560 cfg,
561 auto_cfg,
562 auto_cfg_change,
563 fake_variadic,
564 keyword,
565 attribute,
566 masked,
567 notable_trait,
568 search_unbox,
569 html_favicon_url,
570 html_logo_url,
571 html_playground_url,
572 html_root_url,
573 html_no_source,
574 issue_tracker_base_url,
575 rust_logo,
576 test_attrs,
577 no_crate_inject,
578 } = self;
579 rustc_serialize::Encodable::<E>::encode(first_span, encoder);
580 rustc_serialize::Encodable::<E>::encode(aliases, encoder);
581 rustc_serialize::Encodable::<E>::encode(hidden, encoder);
582
583 let inline = inline.filter(|(i, _)| *i != DocInline::Inline);
587 rustc_serialize::Encodable::<E>::encode(&inline, encoder);
588
589 rustc_serialize::Encodable::<E>::encode(cfg, encoder);
590 rustc_serialize::Encodable::<E>::encode(auto_cfg, encoder);
591 rustc_serialize::Encodable::<E>::encode(auto_cfg_change, encoder);
592 rustc_serialize::Encodable::<E>::encode(fake_variadic, encoder);
593 rustc_serialize::Encodable::<E>::encode(keyword, encoder);
594 rustc_serialize::Encodable::<E>::encode(attribute, encoder);
595 rustc_serialize::Encodable::<E>::encode(masked, encoder);
596 rustc_serialize::Encodable::<E>::encode(notable_trait, encoder);
597 rustc_serialize::Encodable::<E>::encode(search_unbox, encoder);
598 rustc_serialize::Encodable::<E>::encode(html_favicon_url, encoder);
599 rustc_serialize::Encodable::<E>::encode(html_logo_url, encoder);
600 rustc_serialize::Encodable::<E>::encode(html_playground_url, encoder);
601 rustc_serialize::Encodable::<E>::encode(html_root_url, encoder);
602 rustc_serialize::Encodable::<E>::encode(html_no_source, encoder);
603 rustc_serialize::Encodable::<E>::encode(issue_tracker_base_url, encoder);
604 rustc_serialize::Encodable::<E>::encode(rust_logo, encoder);
605 rustc_serialize::Encodable::<E>::encode(test_attrs, encoder);
606 rustc_serialize::Encodable::<E>::encode(no_crate_inject, encoder);
607 }
608}
609
610#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcShowSpansKind {
#[inline]
fn clone(&self) -> Self {
match self {
Self::Expr => RustcShowSpansKind::Expr,
Self::Ty => RustcShowSpansKind::Ty,
Self::Path => RustcShowSpansKind::Path,
}
}
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcShowSpansKind {
#[inline]
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",
})
}
}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),
}
match *self {
RustcShowSpansKind::Expr => {}
RustcShowSpansKind::Ty => {}
RustcShowSpansKind::Path => {}
}
}
}
};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 }
};
::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 }
n => {
::core::panicking::panic_fmt(format_args!("invalid enum variant tag while decoding `RustcShowSpansKind`, expected 0..3, 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") }
}
}
}
};PrintAttribute)]
611pub enum RustcShowSpansKind {
612 Expr,
613 Ty,
614 Path,
615}
616
617#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcDumpLayoutKind {
#[inline]
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]
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)]
618pub enum RustcDumpLayoutKind {
619 Align,
620 BackendRepr,
621 Debug,
622 HomogenousAggregate,
623 LargestNiche,
624 Size,
625}
626
627#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcMirKind {
#[inline]
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]
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)]
628pub enum RustcMirKind {
629 PrettyLiveLocals,
630 PrettyPreciseLiveness,
631 PrettyTransitiveLiveLocals,
632 PeekMaybeInit,
633 PeekMaybeUninit,
634 PeekLiveness,
635 StopAfterDataflow,
636 BorrowckGraphvizPostflow { path: PathBuf },
637 BorrowckGraphvizFormat { format: BorrowckGraphvizFormatKind },
638}
639
640#[derive(#[automatically_derived]impl ::core::clone::Clone for
BorrowckGraphvizFormatKind {
#[inline]
fn clone(&self) -> Self { BorrowckGraphvizFormatKind::TwoPhase }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for BorrowckGraphvizFormatKind
{
#[inline]
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)]
641pub enum BorrowckGraphvizFormatKind {
642 TwoPhase,
643}
644
645#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanAttribute {
#[inline]
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]
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)]
646#[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)]
647pub struct RustcCleanAttribute {
648 pub span: Span,
649 pub cfg: Symbol,
650 pub except: Option<RustcCleanQueries>,
651 pub loaded_from_disk: Option<RustcCleanQueries>,
652}
653
654#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcCleanQueries {
#[inline]
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]
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)]
656#[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)]
657pub struct RustcCleanQueries {
658 pub entries: ThinVec<Symbol>,
659 pub span: Span,
660}
661
662#[derive(#[automatically_derived]impl ::core::clone::Clone for RustcAutodiff {
#[inline]
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]
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)]
663#[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)]
664pub struct RustcAutodiff {
665 pub mode: DiffMode,
669 pub width: u32,
680 pub input_activity: ThinVec<DiffActivity>,
681 pub ret_activity: DiffActivity,
682}
683
684impl RustcAutodiff {
685 pub fn has_primal_ret(&self) -> bool {
686 #[allow(non_exhaustive_omitted_patterns)] match self.ret_activity {
DiffActivity::Active | DiffActivity::Dual => true,
_ => false,
}matches!(self.ret_activity, DiffActivity::Active | DiffActivity::Dual)
687 }
688}
689
690impl RustcAutodiff {
691 pub fn has_ret_activity(&self) -> bool {
692 self.ret_activity != DiffActivity::None
693 }
694 pub fn has_active_only_ret(&self) -> bool {
695 self.ret_activity == DiffActivity::ActiveOnly
696 }
697
698 pub fn error() -> Self {
699 RustcAutodiff {
700 mode: DiffMode::Error,
701 width: 0,
702 ret_activity: DiffActivity::None,
703 input_activity: ThinVec::new(),
704 }
705 }
706
707 pub fn source() -> Self {
708 RustcAutodiff {
709 mode: DiffMode::Source,
710 width: 0,
711 ret_activity: DiffActivity::None,
712 input_activity: ThinVec::new(),
713 }
714 }
715
716 pub fn is_active(&self) -> bool {
717 self.mode != DiffMode::Error
718 }
719
720 pub fn is_source(&self) -> bool {
721 self.mode == DiffMode::Source
722 }
723 pub fn apply_autodiff(&self) -> bool {
724 !#[allow(non_exhaustive_omitted_patterns)] match self.mode {
DiffMode::Error | DiffMode::Source => true,
_ => false,
}matches!(self.mode, DiffMode::Error | DiffMode::Source)
725 }
726
727 pub fn into_item(
728 self,
729 source: String,
730 target: String,
731 inputs: Vec<TypeTree>,
732 output: TypeTree,
733 ) -> AutoDiffItem {
734 AutoDiffItem { source, target, inputs, output, attrs: self }
735 }
736}
737
738#[derive(#[automatically_derived]impl ::core::clone::Clone for AutoDiffItem {
#[inline]
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]
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)]
740pub struct AutoDiffItem {
741 pub source: String,
743 pub target: String,
745 pub attrs: RustcAutodiff,
746 pub inputs: Vec<TypeTree>,
747 pub output: TypeTree,
748}
749
750impl fmt::Display for AutoDiffItem {
751 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
752 f.write_fmt(format_args!("Differentiating {0} -> {1}", self.source,
self.target))write!(f, "Differentiating {} -> {}", self.source, self.target)?;
753 f.write_fmt(format_args!(" with attributes: {0:?}", self.attrs))write!(f, " with attributes: {:?}", self.attrs)?;
754 f.write_fmt(format_args!(" with inputs: {0:?}", self.inputs))write!(f, " with inputs: {:?}", self.inputs)?;
755 f.write_fmt(format_args!(" with output: {0:?}", self.output))write!(f, " with output: {:?}", self.output)
756 }
757}
758
759#[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]
fn clone(&self) -> Self { *self }
}Clone, #[automatically_derived]impl ::core::fmt::Debug for RustcAssertVarianceKind {
#[inline]
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)]
760#[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)]
761pub enum RustcAssertVarianceKind {
762 Covariant,
763 Invariant,
764 Contravariant,
765 Bivariant,
766}
767
768#[derive(#[automatically_derived]impl ::core::clone::Clone for UnstableRemovedFeature {
#[inline]
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]
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)]
769pub struct UnstableRemovedFeature {
770 pub feature: Symbol,
771 pub reason: Symbol,
772 pub link: Symbol,
773 pub since: RustcVersion,
774}
775
776#[derive(#[automatically_derived]impl ::core::clone::Clone for AttributeKind {
#[inline]
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::MustNotSupend { reason: __self_0 } =>
AttributeKind::MustNotSupend {
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 => AttributeKind::RustcIntrinsic,
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::RustcShouldNotBeCalledOnConstItems =>
AttributeKind::RustcShouldNotBeCalledOnConstItems,
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::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 =>
AttributeKind::RustcTrivialFieldReads,
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]
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::MustNotSupend { reason: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"MustNotSupend 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 =>
::core::fmt::Formatter::write_str(f, "RustcIntrinsic"),
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::RustcShouldNotBeCalledOnConstItems =>
::core::fmt::Formatter::write_str(f,
"RustcShouldNotBeCalledOnConstItems"),
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::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 =>
::core::fmt::Formatter::write_str(f,
"RustcTrivialFieldReads"),
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::MustNotSupend { 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 =>
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::RustcShouldNotBeCalledOnConstItems =>
171u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcShowSpans(ref __binding_0) =>
172u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
=> 173u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcSkipDuringMethodDispatch {
array: ref __binding_0, boxed_slice: ref __binding_1 } =>
174u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcSpecializationTrait =>
175u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcStdInternalSymbol =>
176u8.stable_hash(__hcx, __hasher),
AttributeKind::RustcStrictCoherence(ref __binding_0) =>
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 =>
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::MustNotSupend { 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 => {}
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::RustcShouldNotBeCalledOnConstItems => {}
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::RustcTestMarker(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
AttributeKind::RustcTrivialFieldReads => {}
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::MustNotSupend { 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 => { 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::RustcShouldNotBeCalledOnConstItems => {
171usize
}
AttributeKind::RustcShowSpans(ref __binding_0) => {
172usize
}
AttributeKind::RustcSimdMonomorphizeLaneLimit(ref __binding_0)
=> {
173usize
}
AttributeKind::RustcSkipDuringMethodDispatch {
array: ref __binding_0, boxed_slice: ref __binding_1 } => {
174usize
}
AttributeKind::RustcSpecializationTrait => { 175usize }
AttributeKind::RustcStdInternalSymbol => { 176usize }
AttributeKind::RustcStrictCoherence(ref __binding_0) => {
177usize
}
AttributeKind::RustcTestMarker(ref __binding_0) => {
178usize
}
AttributeKind::RustcThenThisWouldNeed(ref __binding_0) => {
179usize
}
AttributeKind::RustcTrivialFieldReads => { 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::MustNotSupend { 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 => {}
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::RustcShouldNotBeCalledOnConstItems => {}
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::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 => {}
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::MustNotSupend {
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 }
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::RustcShouldNotBeCalledOnConstItems
}
172usize => {
AttributeKind::RustcShowSpans(::rustc_serialize::Decodable::decode(__decoder))
}
173usize => {
AttributeKind::RustcSimdMonomorphizeLaneLimit(::rustc_serialize::Decodable::decode(__decoder))
}
174usize => {
AttributeKind::RustcSkipDuringMethodDispatch {
array: ::rustc_serialize::Decodable::decode(__decoder),
boxed_slice: ::rustc_serialize::Decodable::decode(__decoder),
}
}
175usize => { AttributeKind::RustcSpecializationTrait }
176usize => { AttributeKind::RustcStdInternalSymbol }
177usize => {
AttributeKind::RustcStrictCoherence(::rustc_serialize::Decodable::decode(__decoder))
}
178usize => {
AttributeKind::RustcTestMarker(::rustc_serialize::Decodable::decode(__decoder))
}
179usize => {
AttributeKind::RustcThenThisWouldNeed(::rustc_serialize::Decodable::decode(__decoder))
}
180usize => { AttributeKind::RustcTrivialFieldReads }
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::MustNotSupend { reason } => {
__p.word("MustNotSupend");
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 => { __p.word("RustcIntrinsic") }
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::RustcShouldNotBeCalledOnConstItems => {
__p.word("RustcShouldNotBeCalledOnConstItems")
}
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::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 => {
__p.word("RustcTrivialFieldReads")
}
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)]
826pub enum AttributeKind {
827 AllowInternalUnsafe(Span),
830
831 AllowInternalUnstable(ThinVec<(Symbol, Span)>, Span),
833
834 AlwaysGca,
836
837 AutomaticallyDerived,
839
840 CfgAttrTrace(ThinVec<(CfgEntry, Span)>),
842
843 CfgTrace(ThinVec<(CfgEntry, Span)>),
845
846 CfiEncoding {
848 encoding: Symbol,
849 },
850
851 Cold,
853
854 CollapseDebugInfo(CollapseMacroDebuginfo),
856
857 CompilerBuiltins,
859
860 ConstContinue(Span),
862
863 Coroutine,
865
866 Coverage(CoverageAttrKind),
868
869 CrateName {
871 name: Symbol,
872 name_span: Span,
873 attr_span: Span,
874 },
875
876 CrateType(ThinVec<CrateType>),
878
879 CustomMir(Option<(MirDialect, Span)>, Option<(MirPhase, Span)>),
881
882 DebuggerVisualizer(ThinVec<DebugVisualizer>),
884
885 DefaultLibAllocator,
887
888 Deprecated {
890 deprecation: Deprecation,
891 span: Span,
892 is_inner: bool,
894 },
895
896 DoNotRecommend,
898
899 Doc(Box<DocAttribute>),
903
904 DocComment {
907 style: AttrStyle,
908 kind: DocFragmentKind,
909 span: Span,
910 comment: Symbol,
911 },
912
913 EiiDeclaration(EiiDecl),
915
916 EiiImpl(Box<EiiImpl>),
918
919 ExportName {
921 name: Symbol,
924 span: Span,
925 },
926
927 ExportStable,
929
930 Feature(ThinVec<Ident>, Span),
932
933 FfiConst,
935
936 FfiPure(Span),
938
939 Fundamental,
941
942 Ignore {
944 span: Span,
945 reason: Option<Symbol>,
947 },
948
949 Inline(InlineAttr, Span),
951
952 InstructionSet(InstructionSetAttr),
954
955 InstrumentFn(InstrumentFnAttr),
957
958 Lang(LangItem),
960
961 Link(ThinVec<LinkEntry>, Span),
963
964 LinkName {
966 name: Symbol,
967 span: Span,
968 },
969
970 LinkOrdinal {
972 ordinal: u16,
973 span: Span,
974 },
975
976 LinkSection {
978 name: Symbol,
979 },
980
981 Linkage(Linkage, Span),
983
984 LintAsPtr,
986
987 LintCheck(ThinVec<LintCheck>),
989
990 LintNeverReturnsNullPtr,
992
993 LintShouldNotBeCalledOnConstItems,
996
997 LoopMatch(Span),
999
1000 MacroEscape,
1002
1003 MacroExport {
1005 span: Span,
1006 local_inner_macros: bool,
1007 },
1008
1009 MacroUse {
1011 span: Span,
1012 arguments: MacroUseArgs,
1013 },
1014
1015 Marker,
1017
1018 MayDangle(Span),
1020
1021 MoveSizeLimit {
1023 limit: Limit,
1024 },
1025
1026 MustNotSupend {
1028 reason: Option<Symbol>,
1029 },
1030
1031 MustUse {
1033 span: Span,
1035 reason: Option<Symbol>,
1037 },
1038
1039 Naked(Span),
1041
1042 NeedsAllocator,
1044
1045 NeedsPanicRuntime,
1047
1048 NoBuiltins,
1050
1051 NoCore,
1053
1054 NoImplicitPrelude,
1056
1057 NoLink,
1059
1060 NoMain,
1062
1063 NoMangle(Span),
1065
1066 NoStd,
1068
1069 NonExhaustive(Span),
1071
1072 OnConst {
1074 span: Span,
1076 directive: Option<Box<Directive>>,
1078 },
1079
1080 OnMove {
1082 directive: Option<Box<Directive>>,
1083 },
1084
1085 OnTypeError {
1087 span: Span,
1088 directive: Option<Box<Directive>>,
1089 },
1090
1091 OnUnimplemented {
1093 directive: Option<Box<Directive>>,
1095 },
1096
1097 OnUnknown {
1099 directive: Option<Box<Directive>>,
1101 },
1102
1103 OnUnmatchedArgs {
1105 directive: Option<Box<Directive>>,
1107 },
1108
1109 Opaque,
1111
1112 Optimize(OptimizeAttr, Span),
1114
1115 PanicRuntime,
1117
1118 PatchableFunctionEntry {
1120 prefix: Option<u8>,
1121 entry: Option<u8>,
1122 section: Option<Symbol>,
1123 },
1124
1125 Path(Symbol, Span),
1127
1128 PatternComplexityLimit {
1130 limit: Limit,
1131 },
1132
1133 PinV2(Span),
1135
1136 PreludeImport,
1138
1139 ProcMacro,
1141
1142 ProcMacroAttribute,
1144
1145 ProcMacroDerive {
1147 trait_name: Symbol,
1148 helper_attrs: ThinVec<Symbol>,
1149 },
1150
1151 ProfilerRuntime,
1153
1154 RecursionLimit {
1156 limit: Limit,
1157 },
1158
1159 ReexportTestHarnessMain(Symbol),
1161
1162 RegisterTool {
1164 attr_tools: ThinVec<Ident>,
1165 lint_tools: ThinVec<Ident>,
1166 },
1167
1168 Repr {
1170 reprs: ThinVec<(ReprAttr, Span)>,
1171 first_span: Span,
1172 },
1173
1174 RustcAbi {
1176 attr_span: Span,
1177 kind: RustcAbiAttrKind,
1178 },
1179
1180 RustcAlign {
1183 align: Align,
1184 span: Span,
1185 },
1186
1187 RustcAllocator,
1189
1190 RustcAllocatorZeroed,
1192
1193 RustcAllocatorZeroedVariant {
1195 name: Symbol,
1196 },
1197
1198 RustcAllowConstFnUnstable(ThinVec<Symbol>, Span),
1200
1201 RustcAllowIncoherentImpl(Span),
1203
1204 RustcAllowLifetimeDependentSpecialization,
1206
1207 RustcAssertVariance {
1209 span: Span,
1210 kind: RustcAssertVarianceKind,
1211 },
1212
1213 RustcAutodiff(Option<Box<RustcAutodiff>>),
1215
1216 RustcBodyStability {
1218 stability: DefaultBodyStability,
1219 span: Span,
1221 },
1222 RustcBuiltinMacro {
1224 builtin_name: Option<Symbol>,
1225 helper_attrs: ThinVec<Symbol>,
1226 },
1227
1228 RustcCanonicalSymbol,
1230
1231 RustcCaptureAnalysis,
1233
1234 RustcCguTestAttr(ThinVec<(Span, CguFields)>),
1236
1237 RustcClean(ThinVec<RustcCleanAttribute>),
1239
1240 RustcCoherenceIsCore,
1242
1243 RustcCoinductive,
1245
1246 RustcComptime(Span),
1248
1249 RustcConfusables {
1251 confusables: ThinVec<Symbol>,
1252 },
1253 RustcConstStability {
1255 stability: PartialConstStability,
1256 span: Span,
1259 },
1260
1261 RustcConstStableIndirect,
1263
1264 RustcConversionSuggestion,
1266
1267 RustcDeallocator,
1269
1270 RustcDelayedBugFromInsideQuery,
1272
1273 RustcDenyExplicitImpl,
1275
1276 RustcDeprecatedSafe2024 {
1278 suggestion: Symbol,
1279 },
1280 RustcDiagnosticItem(Symbol),
1282
1283 RustcDoNotConstCheck,
1285
1286 RustcDocPrimitive(Span, Symbol),
1288
1289 RustcDummy,
1291
1292 RustcDumpClauses,
1294
1295 RustcDumpDefParents,
1297
1298 RustcDumpDefPath(Span),
1300
1301 RustcDumpGenerics,
1303
1304 RustcDumpHiddenTypeOfOpaques,
1306
1307 RustcDumpInferredOutlives,
1309
1310 RustcDumpItemBounds,
1312
1313 RustcDumpLayout(ThinVec<RustcDumpLayoutKind>),
1315
1316 RustcDumpObjectLifetimeDefaults,
1318
1319 RustcDumpSymbolName(Span),
1321
1322 RustcDumpUserArgs,
1324
1325 RustcDumpVariances,
1327
1328 RustcDumpVariancesOfOpaques,
1330
1331 RustcDumpVtable(Span),
1333
1334 RustcDynIncompatibleTrait(Span),
1336
1337 RustcEffectiveVisibility,
1339
1340 RustcEiiForeignItem,
1342
1343 RustcEvaluateWhereClauses,
1345
1346 RustcHasIncoherentInherentImpls,
1347
1348 RustcIfThisChanged(Span, Option<Symbol>),
1350
1351 RustcInheritOverflowChecks,
1353
1354 RustcInsignificantDtor,
1356
1357 RustcIntrinsic,
1359
1360 RustcIntrinsicConstStableIndirect,
1362
1363 RustcLegacyConstGenerics {
1365 fn_indexes: ThinVec<(usize, Span)>,
1366 attr_span: Span,
1367 },
1368
1369 RustcLintOptDenyFieldAccess {
1371 lint_message: Symbol,
1372 },
1373
1374 RustcLintOptTy,
1376
1377 RustcLintQueryInstability,
1379
1380 RustcLintUntrackedQueryInformation,
1382
1383 RustcMacroTransparency(Transparency),
1385
1386 RustcMain,
1388
1389 RustcMir(ThinVec<RustcMirKind>),
1391
1392 RustcMustImplementOneOf {
1394 attr_span: Span,
1395 fn_names: ThinVec<Ident>,
1396 },
1397
1398 RustcMustMatchExhaustively(Span),
1400
1401 RustcNoImplicitAutorefs,
1403
1404 RustcNoImplicitBounds,
1406
1407 RustcNoMirInline,
1409
1410 RustcNoWritable,
1412
1413 RustcNonConstTraitMethod,
1415
1416 RustcNonnullOptimizationGuaranteed,
1418
1419 RustcNounwind,
1421
1422 RustcObjcClass {
1424 classname: Symbol,
1425 },
1426
1427 RustcObjcSelector {
1429 methname: Symbol,
1430 },
1431
1432 RustcOffloadKernel,
1434
1435 RustcPanicsWhenZero,
1437
1438 RustcParenSugar,
1440
1441 RustcPassByValue,
1443
1444 RustcPassIndirectlyInNonRusticAbis(Span),
1446
1447 RustcPreserveUbChecks,
1449
1450 RustcProcMacroDecls,
1452
1453 RustcPubTransparent(Span),
1455
1456 RustcReallocator,
1458
1459 RustcRegions,
1461
1462 RustcScalableVector {
1464 element_count: Option<u16>,
1467 },
1468
1469 RustcShouldNotBeCalledOnConstItems,
1471
1472 RustcShowSpans(ThinVec<RustcShowSpansKind>),
1474
1475 RustcSimdMonomorphizeLaneLimit(Limit),
1477
1478 RustcSkipDuringMethodDispatch {
1480 array: bool,
1481 boxed_slice: bool,
1482 },
1483
1484 RustcSpecializationTrait,
1486
1487 RustcStdInternalSymbol,
1489
1490 RustcStrictCoherence(Span),
1492
1493 RustcTestMarker(Symbol),
1495
1496 RustcThenThisWouldNeed(ThinVec<Ident>),
1498
1499 RustcTrivialFieldReads,
1501
1502 Sanitize {
1508 on_set: SanitizerSet,
1509 off_set: SanitizerSet,
1510 rtsan: Option<RtsanSetting>,
1511 span: Span,
1512 },
1513
1514 ShouldPanic {
1516 reason: Option<Symbol>,
1517 },
1518
1519 Splat(Span),
1521
1522 Stability {
1524 stability: Stability,
1525 span: Span,
1527 },
1528
1529 TargetFeature {
1532 features: ThinVec<(Symbol, Span)>,
1533 attr_span: Span,
1534 was_forced: bool,
1535 },
1536
1537 TestRunner(Path),
1539
1540 ThreadLocal,
1542
1543 TrackCaller(Span),
1545
1546 TypeLengthLimit {
1548 limit: Limit,
1549 },
1550
1551 UncheckedTypeAlias,
1554
1555 Unroll(UnrollAttr),
1558
1559 UnstableFeatureBound(ThinVec<(Symbol, Span)>),
1561
1562 UnstableRemoved(ThinVec<UnstableRemovedFeature>),
1564
1565 Used {
1567 used_by: UsedBy,
1568 },
1569
1570 WindowsSubsystem(WindowsSubsystemKind),
1572 }