Skip to main content

rustc_attr_ir/
target.rs

1//! This module lists attribute targets, with conversions from other types.
2
3use 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/// This enum lists all possible types of AST items.
17#[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    // Target types that may correspond to different kinds of items.
20    Delegation {
21        mac: bool,
22    },
23    MacroCall,
24
25    // Target types that correspond exclusively to `AssocItem` kind. Mapping is obtained from `Target::from_assoc_item_kind`.
26    AssocConst(&'a ConstItem, AssocCtxt),
27    Method(&'a Fn, MethodKind),
28    AssocTy(&'a TyAlias, AssocCtxt),
29
30    // Target types that correspond exclusively to `ForeignItem` kind. Mapping is obtained from `Target::from_foreign_item_kind`.
31    ForeignStatic(&'a StaticItem),
32    ForeignFn(&'a Fn),
33    ForeignTy(&'a TyAlias),
34
35    // Target types that correspond exclusively to `Item` kind. Mapping is obtained from `Target::from_ast_item`.
36    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    // Target types that correspond exclusively to `Expr` kind. Mapping is obtained from `Target::from_expr`.
54    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    /// Used when it is not possible to obtain detailed AST information.
69    /// In this case, None is just a wrapper for `Target`.
70    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    /// Method in a `trait Trait` block
82    Trait {
83        /// Whether a default is provided for this method
84        body: bool,
85    },
86    /// Method in a `impl Trait for Type` block
87    TraitImpl,
88    /// Method in a `impl Type` block
89    Inherent,
90}
91
92// FIXME(rtjkro): `AstTarget` has nearly one-to-one mapping with `Target`, barring the extra fields from `AssocConst`, `Method`, and `AssocTy`.
93// In the future, remove `Target` and use `AstTarget` instead.
94#[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}