1use std::fmt::{self, Display};
4
5use rustc_abi::ExternAbi;
6pub use rustc_ast::visit::AssocCtxt;
7use rustc_ast::{
8 Arm, AssocItemKind, Closure, ConstBlockItem, ConstItem, Crate, EnumDef, Expr, ExprField,
9 FieldDef, Fn, ForeignItemKind, ForeignMod, GenericParam, GenericParamKind, Generics, Impl,
10 InlineAsm, MacroDef, ModKind, Param, Pat, Safety, StaticItem, Stmt, Trait, TraitAlias, TyAlias,
11 UseTree, Variant, VariantData, WherePredicate, ast,
12};
13use rustc_macros::StableHash;
14use rustc_span::{Ident, Symbol};
15
16#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl<'a>
::core::clone::TrivialClone for AstTarget<'a> {
}
#[automatically_derived]impl<'a> ::core::clone::Clone for AstTarget<'a> {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<bool>;
let _: ::core::clone::AssertParamIsClone<&'a ConstItem>;
let _: ::core::clone::AssertParamIsClone<AssocCtxt>;
let _: ::core::clone::AssertParamIsClone<&'a Fn>;
let _: ::core::clone::AssertParamIsClone<MethodKind>;
let _: ::core::clone::AssertParamIsClone<&'a TyAlias>;
let _: ::core::clone::AssertParamIsClone<&'a StaticItem>;
let _: ::core::clone::AssertParamIsClone<&'a Fn>;
let _: ::core::clone::AssertParamIsClone<&'a TyAlias>;
let _: ::core::clone::AssertParamIsClone<&'a Option<Symbol>>;
let _: ::core::clone::AssertParamIsClone<&'a Ident>;
let _: ::core::clone::AssertParamIsClone<&'a UseTree>;
let _: ::core::clone::AssertParamIsClone<&'a StaticItem>;
let _: ::core::clone::AssertParamIsClone<ConstTypeAstTarget<'a>>;
let _: ::core::clone::AssertParamIsClone<&'a Fn>;
let _: ::core::clone::AssertParamIsClone<&'a Safety>;
let _: ::core::clone::AssertParamIsClone<&'a Ident>;
let _: ::core::clone::AssertParamIsClone<&'a ModKind>;
let _: ::core::clone::AssertParamIsClone<&'a ForeignMod>;
let _: ::core::clone::AssertParamIsClone<&'a InlineAsm>;
let _: ::core::clone::AssertParamIsClone<&'a TyAlias>;
let _: ::core::clone::AssertParamIsClone<&'a Ident>;
let _: ::core::clone::AssertParamIsClone<&'a Generics>;
let _: ::core::clone::AssertParamIsClone<&'a EnumDef>;
let _: ::core::clone::AssertParamIsClone<&'a Ident>;
let _: ::core::clone::AssertParamIsClone<&'a Generics>;
let _: ::core::clone::AssertParamIsClone<&'a VariantData>;
let _: ::core::clone::AssertParamIsClone<&'a Ident>;
let _: ::core::clone::AssertParamIsClone<&'a Generics>;
let _: ::core::clone::AssertParamIsClone<&'a VariantData>;
let _: ::core::clone::AssertParamIsClone<&'a Trait>;
let _: ::core::clone::AssertParamIsClone<&'a TraitAlias>;
let _: ::core::clone::AssertParamIsClone<&'a Impl>;
let _: ::core::clone::AssertParamIsClone<&'a Ident>;
let _: ::core::clone::AssertParamIsClone<&'a MacroDef>;
let _: ::core::clone::AssertParamIsClone<&'a Closure>;
let _: ::core::clone::AssertParamIsClone<&'a Expr>;
let _: ::core::clone::AssertParamIsClone<&'a Arm>;
let _: ::core::clone::AssertParamIsClone<&'a Crate>;
let _: ::core::clone::AssertParamIsClone<&'a ExprField>;
let _: ::core::clone::AssertParamIsClone<&'a FieldDef>;
let _: ::core::clone::AssertParamIsClone<&'a GenericParam>;
let _: ::core::clone::AssertParamIsClone<&'a Param>;
let _: ::core::clone::AssertParamIsClone<&'a Pat>;
let _: ::core::clone::AssertParamIsClone<&'a Stmt>;
let _: ::core::clone::AssertParamIsClone<&'a Variant>;
let _: ::core::clone::AssertParamIsClone<&'a WherePredicate>;
let _: ::core::clone::AssertParamIsClone<Target>;
*self
}
}Clone, #[automatically_derived]impl<'a> ::core::marker::Copy for AstTarget<'a> { }Copy, #[automatically_derived]impl<'a> ::core::fmt::Debug for AstTarget<'a> {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Delegation { mac: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Delegation mac", &__self_0),
Self::MacroCall =>
::core::fmt::Formatter::write_str(f, "MacroCall"),
Self::AssocConst(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"AssocConst", __self_0, &__self_1),
Self::Method(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"Method", __self_0, &__self_1),
Self::AssocTy(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"AssocTy", __self_0, &__self_1),
Self::ForeignStatic(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ForeignStatic", &__self_0),
Self::ForeignFn(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ForeignFn", &__self_0),
Self::ForeignTy(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ForeignTy", &__self_0),
Self::ExternCrate(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"ExternCrate", __self_0, &__self_1),
Self::Use(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Use",
&__self_0),
Self::Static(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Static", &__self_0),
Self::Const(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Const",
&__self_0),
Self::Fn(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Fn",
&__self_0),
Self::Mod(__self_0, __self_1, __self_2) =>
::core::fmt::Formatter::debug_struct_field3_finish(f, "Mod",
__self_0, __self_1, &__self_2),
Self::ForeignMod(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ForeignMod", &__self_0),
Self::GlobalAsm(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"GlobalAsm", &__self_0),
Self::TyAlias(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"TyAlias", &__self_0),
Self::Enum(__self_0, __self_1, __self_2) =>
::core::fmt::Formatter::debug_struct_field3_finish(f, "Enum",
__self_0, __self_1, &__self_2),
Self::Struct(__self_0, __self_1, __self_2) =>
::core::fmt::Formatter::debug_struct_field3_finish(f,
"Struct", __self_0, __self_1, &__self_2),
Self::Union(__self_0, __self_1, __self_2) =>
::core::fmt::Formatter::debug_struct_field3_finish(f, "Union",
__self_0, __self_1, &__self_2),
Self::Trait(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Trait",
&__self_0),
Self::TraitAlias(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"TraitAlias", &__self_0),
Self::Impl(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Impl",
&__self_0),
Self::MacroDef(__self_0, __self_1) =>
::core::fmt::Formatter::debug_struct_field2_finish(f,
"MacroDef", __self_0, &__self_1),
Self::Closure(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Closure", &__self_0),
Self::Expression(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Expression", &__self_0),
Self::Arm(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Arm",
&__self_0),
Self::Crate(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Crate",
&__self_0),
Self::ExprField(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ExprField", &__self_0),
Self::Field(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Field",
&__self_0),
Self::GenericParam(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"GenericParam", &__self_0),
Self::Param(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "Param",
&__self_0),
Self::PatField(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"PatField", &__self_0),
Self::Statement(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Statement", &__self_0),
Self::Variant(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Variant", &__self_0),
Self::WherePredicate(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"WherePredicate", &__self_0),
Self::None(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f, "None",
&__self_0),
}
}
}Debug)]
18pub enum AstTarget<'a> {
19 Delegation {
21 mac: bool,
22 },
23 MacroCall,
24
25 AssocConst(&'a ConstItem, AssocCtxt),
27 Method(&'a Fn, MethodKind),
28 AssocTy(&'a TyAlias, AssocCtxt),
29
30 ForeignStatic(&'a StaticItem),
32 ForeignFn(&'a Fn),
33 ForeignTy(&'a TyAlias),
34
35 ExternCrate(&'a Option<Symbol>, &'a Ident),
37 Use(&'a UseTree),
38 Static(&'a StaticItem),
39 Const(ConstTypeAstTarget<'a>),
40 Fn(&'a Fn),
41 Mod(&'a Safety, &'a Ident, &'a ModKind),
42 ForeignMod(&'a ForeignMod),
43 GlobalAsm(&'a InlineAsm),
44 TyAlias(&'a TyAlias),
45 Enum(&'a Ident, &'a Generics, &'a EnumDef),
46 Struct(&'a Ident, &'a Generics, &'a VariantData),
47 Union(&'a Ident, &'a Generics, &'a VariantData),
48 Trait(&'a Trait),
49 TraitAlias(&'a TraitAlias),
50 Impl(&'a Impl),
51 MacroDef(&'a Ident, &'a MacroDef),
52
53 Closure(&'a Closure),
55 Expression(&'a Expr),
56
57 Arm(&'a Arm),
58 Crate(&'a Crate),
59 ExprField(&'a ExprField),
60 Field(&'a FieldDef),
61 GenericParam(&'a GenericParam),
62 Param(&'a Param),
63 PatField(&'a Pat),
64 Statement(&'a Stmt),
65 Variant(&'a Variant),
66 WherePredicate(&'a WherePredicate),
67
68 None(Target),
71}
72
73#[derive(#[automatically_derived]#[doc(hidden)]unsafe impl<'a>
::core::clone::TrivialClone for ConstTypeAstTarget<'a> {
}
#[automatically_derived]impl<'a> ::core::clone::Clone for
ConstTypeAstTarget<'a> {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<&'a ConstItem>;
let _: ::core::clone::AssertParamIsClone<&'a ConstBlockItem>;
*self
}
}Clone, #[automatically_derived]impl<'a> ::core::marker::Copy for
ConstTypeAstTarget<'a> {
}Copy, #[automatically_derived]impl<'a> ::core::fmt::Debug for ConstTypeAstTarget<'a>
{
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::ConstItem(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ConstItem", &__self_0),
Self::ConstBlockItem(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"ConstBlockItem", &__self_0),
}
}
}Debug)]
74pub enum ConstTypeAstTarget<'a> {
75 ConstItem(&'a ConstItem),
76 ConstBlockItem(&'a ConstBlockItem),
77}
78
79#[derive(#[automatically_derived]impl ::core::marker::Copy for MethodKind { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for MethodKind {
}
#[automatically_derived]impl ::core::clone::Clone for MethodKind {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<bool>;
*self
}
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for
MethodKind {
}
#[automatically_derived]impl ::core::cmp::PartialEq for MethodKind {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Trait { body: __self_0 }, Self::Trait { body: __arg1_0
}) => __self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, #[automatically_derived]impl ::core::fmt::Debug for MethodKind {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::Trait { body: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Trait body", &__self_0),
Self::TraitImpl =>
::core::fmt::Formatter::write_str(f, "TraitImpl"),
Self::Inherent =>
::core::fmt::Formatter::write_str(f, "Inherent"),
}
}
}Debug, #[automatically_derived]impl ::core::cmp::Eq for MethodKind {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<bool>;
}
}Eq, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for MethodKind {
#[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 {
MethodKind::Trait { body: ref __binding_0 } =>
0u8.stable_hash(__hcx, __hasher),
MethodKind::TraitImpl => 1u8.stable_hash(__hcx, __hasher),
MethodKind::Inherent => 2u8.stable_hash(__hcx, __hasher),
}
match *self {
MethodKind::Trait { body: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
MethodKind::TraitImpl => {}
MethodKind::Inherent => {}
}
}
}
};StableHash)]
80pub enum MethodKind {
81 Trait {
83 body: bool,
85 },
86 TraitImpl,
88 Inherent,
90}
91
92#[derive(#[automatically_derived]impl ::core::marker::Copy for Target { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for Target {
}
#[automatically_derived]impl ::core::clone::Clone for Target {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<bool>;
let _: ::core::clone::AssertParamIsClone<AssocCtxt>;
let _: ::core::clone::AssertParamIsClone<MethodKind>;
*self
}
}Clone, #[automatically_derived]impl ::core::marker::StructuralPartialEq for Target {
}
#[automatically_derived]impl ::core::cmp::PartialEq for Target {
#[inline]
fn eq(&self, other: &Self) -> bool {
::core::intrinsics::discriminant_value(self) ==
::core::intrinsics::discriminant_value(other) &&
match (self, other) {
(Self::Impl { of_trait: __self_0 }, Self::Impl {
of_trait: __arg1_0 }) => __self_0 == __arg1_0,
(Self::AssocConst(__self_0), Self::AssocConst(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::Method(__self_0), Self::Method(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::AssocTy(__self_0), Self::AssocTy(__arg1_0)) =>
__self_0 == __arg1_0,
(Self::Delegation { mac: __self_0 }, Self::Delegation {
mac: __arg1_0 }) => __self_0 == __arg1_0,
_ => true,
}
}
}PartialEq, #[automatically_derived]impl ::core::fmt::Debug for Target {
#[inline]
#[rustc_trivial_field_reads]
fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
match self {
Self::ExternCrate =>
::core::fmt::Formatter::write_str(f, "ExternCrate"),
Self::Use => ::core::fmt::Formatter::write_str(f, "Use"),
Self::Static => ::core::fmt::Formatter::write_str(f, "Static"),
Self::Const => ::core::fmt::Formatter::write_str(f, "Const"),
Self::Fn => ::core::fmt::Formatter::write_str(f, "Fn"),
Self::Closure => ::core::fmt::Formatter::write_str(f, "Closure"),
Self::Mod => ::core::fmt::Formatter::write_str(f, "Mod"),
Self::ForeignMod =>
::core::fmt::Formatter::write_str(f, "ForeignMod"),
Self::GlobalAsm =>
::core::fmt::Formatter::write_str(f, "GlobalAsm"),
Self::TyAlias => ::core::fmt::Formatter::write_str(f, "TyAlias"),
Self::Enum => ::core::fmt::Formatter::write_str(f, "Enum"),
Self::Variant => ::core::fmt::Formatter::write_str(f, "Variant"),
Self::Struct => ::core::fmt::Formatter::write_str(f, "Struct"),
Self::Field => ::core::fmt::Formatter::write_str(f, "Field"),
Self::Union => ::core::fmt::Formatter::write_str(f, "Union"),
Self::Trait => ::core::fmt::Formatter::write_str(f, "Trait"),
Self::TraitAlias =>
::core::fmt::Formatter::write_str(f, "TraitAlias"),
Self::Impl { of_trait: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Impl of_trait", &__self_0),
Self::Expression =>
::core::fmt::Formatter::write_str(f, "Expression"),
Self::Statement =>
::core::fmt::Formatter::write_str(f, "Statement"),
Self::Arm => ::core::fmt::Formatter::write_str(f, "Arm"),
Self::AssocConst(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"AssocConst", &__self_0),
Self::Method(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Method", &__self_0),
Self::AssocTy(__self_0) =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"AssocTy", &__self_0),
Self::ForeignFn =>
::core::fmt::Formatter::write_str(f, "ForeignFn"),
Self::ForeignStatic =>
::core::fmt::Formatter::write_str(f, "ForeignStatic"),
Self::ForeignTy =>
::core::fmt::Formatter::write_str(f, "ForeignTy"),
Self::LifetimeParam =>
::core::fmt::Formatter::write_str(f, "LifetimeParam"),
Self::TypeParam =>
::core::fmt::Formatter::write_str(f, "TypeParam"),
Self::ConstParam =>
::core::fmt::Formatter::write_str(f, "ConstParam"),
Self::MacroDef =>
::core::fmt::Formatter::write_str(f, "MacroDef"),
Self::Param => ::core::fmt::Formatter::write_str(f, "Param"),
Self::PatField =>
::core::fmt::Formatter::write_str(f, "PatField"),
Self::ExprField =>
::core::fmt::Formatter::write_str(f, "ExprField"),
Self::WherePredicate =>
::core::fmt::Formatter::write_str(f, "WherePredicate"),
Self::MacroCall =>
::core::fmt::Formatter::write_str(f, "MacroCall"),
Self::Crate => ::core::fmt::Formatter::write_str(f, "Crate"),
Self::Delegation { mac: __self_0 } =>
::core::fmt::Formatter::debug_struct_field1_finish(f,
"Delegation mac", &__self_0),
Self::ForLoop => ::core::fmt::Formatter::write_str(f, "ForLoop"),
Self::While => ::core::fmt::Formatter::write_str(f, "While"),
Self::Loop => ::core::fmt::Formatter::write_str(f, "Loop"),
Self::Break => ::core::fmt::Formatter::write_str(f, "Break"),
}
}
}Debug, #[automatically_derived]impl ::core::cmp::Eq for Target {
#[inline]
#[doc(hidden)]
#[coverage(off)]
fn assert_fields_are_eq(&self) {
let _: ::core::cmp::AssertParamIsEq<bool>;
let _: ::core::cmp::AssertParamIsEq<AssocCtxt>;
let _: ::core::cmp::AssertParamIsEq<MethodKind>;
}
}Eq, const _: () =
{
impl ::rustc_data_structures::stable_hash::StableHash for Target {
#[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 {
Target::ExternCrate => 0u8.stable_hash(__hcx, __hasher),
Target::Use => 1u8.stable_hash(__hcx, __hasher),
Target::Static => 2u8.stable_hash(__hcx, __hasher),
Target::Const => 3u8.stable_hash(__hcx, __hasher),
Target::Fn => 4u8.stable_hash(__hcx, __hasher),
Target::Closure => 5u8.stable_hash(__hcx, __hasher),
Target::Mod => 6u8.stable_hash(__hcx, __hasher),
Target::ForeignMod => 7u8.stable_hash(__hcx, __hasher),
Target::GlobalAsm => 8u8.stable_hash(__hcx, __hasher),
Target::TyAlias => 9u8.stable_hash(__hcx, __hasher),
Target::Enum => 10u8.stable_hash(__hcx, __hasher),
Target::Variant => 11u8.stable_hash(__hcx, __hasher),
Target::Struct => 12u8.stable_hash(__hcx, __hasher),
Target::Field => 13u8.stable_hash(__hcx, __hasher),
Target::Union => 14u8.stable_hash(__hcx, __hasher),
Target::Trait => 15u8.stable_hash(__hcx, __hasher),
Target::TraitAlias => 16u8.stable_hash(__hcx, __hasher),
Target::Impl { of_trait: ref __binding_0 } =>
17u8.stable_hash(__hcx, __hasher),
Target::Expression => 18u8.stable_hash(__hcx, __hasher),
Target::Statement => 19u8.stable_hash(__hcx, __hasher),
Target::Arm => 20u8.stable_hash(__hcx, __hasher),
Target::AssocConst(ref __binding_0) =>
21u8.stable_hash(__hcx, __hasher),
Target::Method(ref __binding_0) =>
22u8.stable_hash(__hcx, __hasher),
Target::AssocTy(ref __binding_0) =>
23u8.stable_hash(__hcx, __hasher),
Target::ForeignFn => 24u8.stable_hash(__hcx, __hasher),
Target::ForeignStatic => 25u8.stable_hash(__hcx, __hasher),
Target::ForeignTy => 26u8.stable_hash(__hcx, __hasher),
Target::LifetimeParam => 27u8.stable_hash(__hcx, __hasher),
Target::TypeParam => 28u8.stable_hash(__hcx, __hasher),
Target::ConstParam => 29u8.stable_hash(__hcx, __hasher),
Target::MacroDef => 30u8.stable_hash(__hcx, __hasher),
Target::Param => 31u8.stable_hash(__hcx, __hasher),
Target::PatField => 32u8.stable_hash(__hcx, __hasher),
Target::ExprField => 33u8.stable_hash(__hcx, __hasher),
Target::WherePredicate => 34u8.stable_hash(__hcx, __hasher),
Target::MacroCall => 35u8.stable_hash(__hcx, __hasher),
Target::Crate => 36u8.stable_hash(__hcx, __hasher),
Target::Delegation { mac: ref __binding_0 } =>
37u8.stable_hash(__hcx, __hasher),
Target::ForLoop => 38u8.stable_hash(__hcx, __hasher),
Target::While => 39u8.stable_hash(__hcx, __hasher),
Target::Loop => 40u8.stable_hash(__hcx, __hasher),
Target::Break => 41u8.stable_hash(__hcx, __hasher),
}
match *self {
Target::ExternCrate => {}
Target::Use => {}
Target::Static => {}
Target::Const => {}
Target::Fn => {}
Target::Closure => {}
Target::Mod => {}
Target::ForeignMod => {}
Target::GlobalAsm => {}
Target::TyAlias => {}
Target::Enum => {}
Target::Variant => {}
Target::Struct => {}
Target::Field => {}
Target::Union => {}
Target::Trait => {}
Target::TraitAlias => {}
Target::Impl { of_trait: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
Target::Expression => {}
Target::Statement => {}
Target::Arm => {}
Target::AssocConst(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
Target::Method(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
Target::AssocTy(ref __binding_0) => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
Target::ForeignFn => {}
Target::ForeignStatic => {}
Target::ForeignTy => {}
Target::LifetimeParam => {}
Target::TypeParam => {}
Target::ConstParam => {}
Target::MacroDef => {}
Target::Param => {}
Target::PatField => {}
Target::ExprField => {}
Target::WherePredicate => {}
Target::MacroCall => {}
Target::Crate => {}
Target::Delegation { mac: ref __binding_0 } => {
{ __binding_0.stable_hash(__hcx, __hasher); }
}
Target::ForLoop => {}
Target::While => {}
Target::Loop => {}
Target::Break => {}
}
}
}
};StableHash)]
95pub enum Target {
96 ExternCrate,
97 Use,
98 Static,
99 Const,
100 Fn,
101 Closure,
102 Mod,
103 ForeignMod,
104 GlobalAsm,
105 TyAlias,
106 Enum,
107 Variant,
108 Struct,
109 Field,
110 Union,
111 Trait,
112 TraitAlias,
113 Impl { of_trait: bool },
114 Expression,
115 Statement,
116 Arm,
117 AssocConst(AssocCtxt),
118 Method(MethodKind),
119 AssocTy(AssocCtxt),
120 ForeignFn,
121 ForeignStatic,
122 ForeignTy,
123 LifetimeParam,
124 TypeParam,
125 ConstParam,
126 MacroDef,
127 Param,
128 PatField,
129 ExprField,
130 WherePredicate,
131 MacroCall,
132 Crate,
133 Delegation { mac: bool },
134 ForLoop,
135 While,
136 Loop,
137 Break,
138}
139
140impl<'a> AstTarget<'a> {
141 pub fn get_abi(&self) -> Option<ExternAbi> {
142 let ext = match self {
143 AstTarget::Method(fn_item, _) => fn_item.sig.header.ext,
144 AstTarget::Fn(fn_item) => fn_item.sig.header.ext,
145 AstTarget::ForeignFn(fn_item) => fn_item.sig.header.ext,
146 _ => return None,
147 };
148
149 match ext {
150 ast::Extern::None => Some(ExternAbi::Rust),
151 ast::Extern::Implicit(_) => Some(ExternAbi::FALLBACK),
152 ast::Extern::Explicit(abi, _) => Some(abi.symbol_unescaped.as_str().parse().ok()?),
153 }
154 }
155
156 pub fn get_fn_sig(&self) -> Option<&rustc_ast::ast::FnSig> {
157 match self {
158 AstTarget::Method(fn_item, _) => Some(&fn_item.sig),
159 AstTarget::Fn(fn_item) => Some(&fn_item.sig),
160 AstTarget::ForeignFn(fn_item) => Some(&fn_item.sig),
161 _ => None,
162 }
163 }
164
165 pub fn from_foreign_item_kind(kind: &'a ast::ForeignItemKind) -> Self {
166 match kind {
167 ForeignItemKind::Static(static_item) => AstTarget::ForeignStatic(static_item),
168 ForeignItemKind::Fn(f) => AstTarget::ForeignFn(f),
169 ForeignItemKind::TyAlias(ty_alias) => AstTarget::ForeignTy(ty_alias),
170 ForeignItemKind::MacCall(_) => AstTarget::MacroCall,
171 }
172 }
173
174 pub fn from_assoc_item_kind(kind: &'a ast::AssocItemKind, assoc_ctxt: AssocCtxt) -> Self {
175 match kind {
176 AssocItemKind::Const(const_item) => AstTarget::AssocConst(const_item, assoc_ctxt),
177 AssocItemKind::Fn(f) => AstTarget::Method(
178 f,
179 match assoc_ctxt {
180 AssocCtxt::Trait => MethodKind::Trait { body: f.body.is_some() },
181 AssocCtxt::Impl { of_trait, .. } => {
182 if of_trait {
183 MethodKind::TraitImpl
184 } else {
185 MethodKind::Inherent
186 }
187 }
188 },
189 ),
190 AssocItemKind::Type(type_alias) => AstTarget::AssocTy(type_alias, assoc_ctxt),
191 AssocItemKind::Delegation(_) => AstTarget::Delegation { mac: false },
192 AssocItemKind::DelegationMac(_) => AstTarget::Delegation { mac: true },
193 AssocItemKind::MacCall(_) => AstTarget::MacroCall,
194 }
195 }
196
197 pub fn from_ast_item(kind: &'a ast::ItemKind) -> Self {
198 match kind {
199 ast::ItemKind::ExternCrate(symbol, ident) => AstTarget::ExternCrate(symbol, ident),
200 ast::ItemKind::Use(use_tree) => AstTarget::Use(use_tree),
201 ast::ItemKind::Static(static_item) => AstTarget::Static(static_item),
202 ast::ItemKind::Const(const_item) => {
203 AstTarget::Const(ConstTypeAstTarget::ConstItem(const_item))
204 }
205 ast::ItemKind::ConstBlock(const_block_item) => {
206 AstTarget::Const(ConstTypeAstTarget::ConstBlockItem(const_block_item))
207 }
208 ast::ItemKind::Fn(f) => AstTarget::Fn(f),
209 ast::ItemKind::Mod(s, i, mk) => AstTarget::Mod(s, i, mk),
210 ast::ItemKind::ForeignMod(foreign_mod) => AstTarget::ForeignMod(foreign_mod),
211 ast::ItemKind::GlobalAsm(inline_asm) => AstTarget::GlobalAsm(inline_asm),
212 ast::ItemKind::TyAlias(ty_alias) => AstTarget::TyAlias(ty_alias),
213 ast::ItemKind::Enum(i, g, ed) => AstTarget::Enum(i, g, ed),
214 ast::ItemKind::Struct(i, g, vd) => AstTarget::Struct(i, g, vd),
215 ast::ItemKind::Union(i, g, vd) => AstTarget::Union(i, g, vd),
216 ast::ItemKind::Trait(trait_kind) => AstTarget::Trait(trait_kind),
217 ast::ItemKind::TraitAlias(trait_alias) => AstTarget::TraitAlias(trait_alias),
218 ast::ItemKind::Impl(i) => AstTarget::Impl(i),
219 ast::ItemKind::MacCall(..) => AstTarget::MacroCall,
220 ast::ItemKind::MacroDef(ident, macro_def) => AstTarget::MacroDef(ident, macro_def),
221 ast::ItemKind::Delegation(..) => AstTarget::Delegation { mac: false },
222 ast::ItemKind::DelegationMac(..) => AstTarget::Delegation { mac: true },
223 ast::ItemKind::TestBinderConstraints(..) => AstTarget::MacroCall,
224 }
225 }
226}
227
228impl Display for Target {
229 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
230 f.write_fmt(format_args!("{0}", Self::name(*self)))write!(f, "{}", Self::name(*self))
231 }
232}
233
234impl ::rustc_error_messages::IntoDiagArg for Target {
fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>)
-> ::rustc_error_messages::DiagArgValue {
self.to_string().into_diag_arg(path)
}
}rustc_error_messages::into_diag_arg_using_display!(Target);
235
236impl Target {
237 pub fn from_ast_target(ast_item: &AstTarget<'_>) -> Self {
238 match ast_item {
239 AstTarget::Delegation { mac } => Target::Delegation { mac: *mac },
240 AstTarget::MacroCall => Target::MacroCall,
241
242 AstTarget::AssocConst(_, assoc_ctxt) => Target::AssocConst(*assoc_ctxt),
243 AstTarget::Method(_, method_kind) => Target::Method(*method_kind),
244 AstTarget::AssocTy(_, assoc_ctxt) => Target::AssocTy(*assoc_ctxt),
245
246 AstTarget::ForeignStatic(_) => Target::ForeignStatic,
247 AstTarget::ForeignFn(_) => Target::ForeignFn,
248 AstTarget::ForeignTy(_) => Target::ForeignTy,
249
250 AstTarget::ExternCrate(..) => Target::ExternCrate,
251 AstTarget::Use(_) => Target::Use,
252 AstTarget::Static(_) => Target::Static,
253 AstTarget::Const(_) => Target::Const,
254 AstTarget::Fn(_) => Target::Fn,
255 AstTarget::Mod(..) => Target::Mod,
256 AstTarget::ForeignMod(_) => Target::ForeignMod,
257 AstTarget::GlobalAsm(_) => Target::GlobalAsm,
258 AstTarget::TyAlias(_) => Target::TyAlias,
259 AstTarget::Enum(..) => Target::Enum,
260 AstTarget::Struct(..) => Target::Struct,
261 AstTarget::Union(..) => Target::Union,
262 AstTarget::Trait(_) => Target::Trait,
263 AstTarget::TraitAlias(_) => Target::TraitAlias,
264 AstTarget::Impl(i) => Target::Impl { of_trait: i.of_trait.is_some() },
265 AstTarget::MacroDef(..) => Target::MacroDef,
266
267 AstTarget::Closure(_) => Target::Closure,
268 AstTarget::Expression(e) => Target::from_expr(e),
269
270 AstTarget::Arm(_) => Target::Arm,
271 AstTarget::Crate(_) => Target::Crate,
272 AstTarget::ExprField(_) => Target::ExprField,
273 AstTarget::Field(_) => Target::Field,
274 AstTarget::GenericParam(g) => match g.kind {
275 GenericParamKind::Type { .. } => Target::TypeParam,
276 GenericParamKind::Lifetime => Target::LifetimeParam,
277 GenericParamKind::Const { .. } => Target::ConstParam,
278 },
279 AstTarget::Param(_) => Target::Param,
280 AstTarget::PatField(_) => Target::PatField,
281 AstTarget::Statement(_) => Target::Statement,
282 AstTarget::Variant(_) => Target::Variant,
283 AstTarget::WherePredicate(_) => Target::WherePredicate,
284
285 AstTarget::None(target) => *target,
286 }
287 }
288
289 pub fn is_associated_item(self) -> bool {
290 match self {
291 Target::AssocConst(_) | Target::AssocTy(_) | Target::Method(_) => true,
292 Target::ExternCrate
293 | Target::Use
294 | Target::Static
295 | Target::Const
296 | Target::Fn
297 | Target::Closure
298 | Target::Mod
299 | Target::ForeignMod
300 | Target::GlobalAsm
301 | Target::TyAlias
302 | Target::Enum
303 | Target::Variant
304 | Target::Struct
305 | Target::Field
306 | Target::Union
307 | Target::Trait
308 | Target::TraitAlias
309 | Target::Impl { .. }
310 | Target::Expression
311 | Target::Statement
312 | Target::Arm
313 | Target::ForeignFn
314 | Target::ForeignStatic
315 | Target::ForeignTy
316 | Target::TypeParam
317 | Target::LifetimeParam
318 | Target::ConstParam
319 | Target::MacroDef
320 | Target::Param
321 | Target::PatField
322 | Target::ExprField
323 | Target::MacroCall
324 | Target::Crate
325 | Target::WherePredicate
326 | Target::Delegation { .. }
327 | Target::Loop
328 | Target::While
329 | Target::ForLoop
330 | Target::Break => false,
331 }
332 }
333 pub fn from_ast_item(item: &ast::Item) -> Target {
334 match item.kind {
335 ast::ItemKind::ExternCrate(..) => Target::ExternCrate,
336 ast::ItemKind::Use(..) => Target::Use,
337 ast::ItemKind::Static { .. } => Target::Static,
338 ast::ItemKind::Const(..) => Target::Const,
339 ast::ItemKind::ConstBlock(..) => Target::Const,
340 ast::ItemKind::Fn { .. } => Target::Fn,
341 ast::ItemKind::Mod(..) => Target::Mod,
342 ast::ItemKind::ForeignMod { .. } => Target::ForeignMod,
343 ast::ItemKind::GlobalAsm { .. } => Target::GlobalAsm,
344 ast::ItemKind::TyAlias(..) => Target::TyAlias,
345 ast::ItemKind::Enum(..) => Target::Enum,
346 ast::ItemKind::Struct(..) => Target::Struct,
347 ast::ItemKind::Union(..) => Target::Union,
348 ast::ItemKind::Trait(..) => Target::Trait,
349 ast::ItemKind::TraitAlias(..) => Target::TraitAlias,
350 ast::ItemKind::Impl(ref i) => Target::Impl { of_trait: i.of_trait.is_some() },
351 ast::ItemKind::MacCall(..) => Target::MacroCall,
352 ast::ItemKind::MacroDef(..) => Target::MacroDef,
353 ast::ItemKind::Delegation(..) => Target::Delegation { mac: false },
354 ast::ItemKind::DelegationMac(..) => Target::Delegation { mac: true },
355 ast::ItemKind::TestBinderConstraints(..) => Target::MacroCall,
356 }
357 }
358
359 pub fn from_foreign_item_kind(kind: &ast::ForeignItemKind) -> Target {
360 match kind {
361 ForeignItemKind::Static(_) => Target::ForeignStatic,
362 ForeignItemKind::Fn(_) => Target::ForeignFn,
363 ForeignItemKind::TyAlias(_) => Target::ForeignTy,
364 ForeignItemKind::MacCall(_) => Target::MacroCall,
365 }
366 }
367
368 pub fn from_assoc_item_kind(kind: &ast::AssocItemKind, assoc_ctxt: AssocCtxt) -> Target {
369 match kind {
370 AssocItemKind::Const(_) => Target::AssocConst(assoc_ctxt),
371 AssocItemKind::Fn(f) => Target::Method(match assoc_ctxt {
372 AssocCtxt::Trait => MethodKind::Trait { body: f.body.is_some() },
373 AssocCtxt::Impl { of_trait, .. } => {
374 if of_trait {
375 MethodKind::TraitImpl
376 } else {
377 MethodKind::Inherent
378 }
379 }
380 }),
381 AssocItemKind::Type(_) => Target::AssocTy(assoc_ctxt),
382 AssocItemKind::Delegation(_) => Target::Delegation { mac: false },
383 AssocItemKind::DelegationMac(_) => Target::Delegation { mac: true },
384 AssocItemKind::MacCall(_) => Target::MacroCall,
385 }
386 }
387
388 pub fn from_expr(expr: &ast::Expr) -> Self {
389 match &expr.kind {
390 ast::ExprKind::Closure(..) | ast::ExprKind::Gen(..) => Self::Closure,
391 ast::ExprKind::Paren(e) => Self::from_expr(&e),
392 ast::ExprKind::ForLoop { .. } => Self::ForLoop,
393 ast::ExprKind::Loop(..) => Self::Loop,
394 ast::ExprKind::While(..) => Self::While,
395 ast::ExprKind::Break(..) => Self::Break,
396 _ => Self::Expression,
397 }
398 }
399
400 pub fn name(self) -> &'static str {
401 match self {
402 Target::ExternCrate => "extern crate",
403 Target::Use => "use",
404 Target::Static => "static",
405 Target::Const => "constant",
406 Target::Fn => "function",
407 Target::Closure => "closure",
408 Target::Mod => "module",
409 Target::ForeignMod => "foreign module",
410 Target::GlobalAsm => "global asm",
411 Target::TyAlias => "type alias",
412 Target::Enum => "enum",
413 Target::Variant => "enum variant",
414 Target::Struct => "struct",
415 Target::Field => "struct field",
416 Target::Union => "union",
417 Target::Trait => "trait",
418 Target::TraitAlias => "trait alias",
419 Target::Impl { .. } => "implementation block",
420 Target::Expression => "expression",
421 Target::Statement => "statement",
422 Target::Arm => "match arm",
423 Target::AssocConst(_) => "associated const",
424 Target::Method(kind) => match kind {
425 MethodKind::Inherent => "inherent method",
426 MethodKind::Trait { body: false } => "required trait method",
427 MethodKind::Trait { body: true } => "provided trait method",
428 MethodKind::TraitImpl => "trait method in an impl block",
429 },
430 Target::AssocTy(_) => "associated type",
431 Target::ForeignFn => "foreign function",
432 Target::ForeignStatic => "foreign static item",
433 Target::ForeignTy => "foreign type",
434 Target::TypeParam => "type parameter",
435 Target::LifetimeParam => "lifetime parameter",
436 Target::ConstParam => "const parameter",
437 Target::MacroDef => "macro def",
438 Target::Param => "function param",
439 Target::PatField => "pattern field",
440 Target::ExprField => "struct field",
441 Target::WherePredicate => "where predicate",
442 Target::MacroCall => "macro call",
443 Target::Crate => "crate",
444 Target::Delegation { .. } => "delegation",
445 Target::Loop => "loop",
446 Target::ForLoop => "for loop",
447 Target::While => "while loop",
448 Target::Break => "break expression",
449 }
450 }
451
452 pub fn plural_name(self) -> &'static str {
453 match self {
454 Target::ExternCrate => "extern crates",
455 Target::Use => "use statements",
456 Target::Static => "statics",
457 Target::Const => "constants",
458 Target::Fn => "functions",
459 Target::Closure => "closures",
460 Target::Mod => "modules",
461 Target::ForeignMod => "foreign modules",
462 Target::GlobalAsm => "global asms",
463 Target::TyAlias => "type aliases",
464 Target::Enum => "enums",
465 Target::Variant => "enum variants",
466 Target::Struct => "structs",
467 Target::Field => "struct fields",
468 Target::Union => "unions",
469 Target::Trait => "traits",
470 Target::TraitAlias => "trait aliases",
471 Target::Impl { of_trait: false } => "inherent impl blocks",
472 Target::Impl { of_trait: true } => "trait impl blocks",
473 Target::Expression => "expressions",
474 Target::Statement => "statements",
475 Target::Arm => "match arms",
476 Target::AssocConst(_) => "associated consts",
477 Target::Method(kind) => match kind {
478 MethodKind::Inherent => "inherent methods",
479 MethodKind::Trait { body: false } => "required trait methods",
480 MethodKind::Trait { body: true } => "provided trait methods",
481 MethodKind::TraitImpl => "trait methods in impl blocks",
482 },
483 Target::AssocTy(_) => "associated types",
484 Target::ForeignFn => "foreign functions",
485 Target::ForeignStatic => "foreign statics",
486 Target::ForeignTy => "foreign types",
487 Target::TypeParam => "type parameters",
488 Target::LifetimeParam => "lifetime parameters",
489 Target::ConstParam => "const parameters",
490 Target::MacroDef => "macro defs",
491 Target::Param => "function params",
492 Target::PatField => "pattern fields",
493 Target::ExprField => "struct fields",
494 Target::WherePredicate => "where predicates",
495 Target::MacroCall => "macro calls",
496 Target::Crate => "crates",
497 Target::Delegation { .. } => "delegations",
498 Target::ForLoop => "for loops",
499 Target::Loop => "loops",
500 Target::While => "while loops",
501 Target::Break => "break expressions",
502 }
503 }
504}