]> git.lizzy.rs Git - rust.git/blob - compiler/rustc_hir/src/target.rs
Rollup merge of #82196 - Manishearth:display-caveat, r=m-ou-se
[rust.git] / compiler / rustc_hir / src / target.rs
1 //! This module implements some validity checks for attributes.
2 //! In particular it verifies that `#[inline]` and `#[repr]` attributes are
3 //! attached to items that actually support them and if there are
4 //! conflicts between multiple such attributes attached to the same
5 //! item.
6
7 use crate::hir;
8 use crate::{Item, ItemKind, TraitItem, TraitItemKind};
9
10 use std::fmt::{self, Display};
11
12 #[derive(Copy, Clone, PartialEq, Debug)]
13 pub enum GenericParamKind {
14     Type,
15     Lifetime,
16     Const,
17 }
18
19 #[derive(Copy, Clone, PartialEq, Debug)]
20 pub enum MethodKind {
21     Trait { body: bool },
22     Inherent,
23 }
24
25 #[derive(Copy, Clone, PartialEq, Debug)]
26 pub enum Target {
27     ExternCrate,
28     Use,
29     Static,
30     Const,
31     Fn,
32     Closure,
33     Mod,
34     ForeignMod,
35     GlobalAsm,
36     TyAlias,
37     OpaqueTy,
38     Enum,
39     Variant,
40     Struct,
41     Field,
42     Union,
43     Trait,
44     TraitAlias,
45     Impl,
46     Expression,
47     Statement,
48     Arm,
49     AssocConst,
50     Method(MethodKind),
51     AssocTy,
52     ForeignFn,
53     ForeignStatic,
54     ForeignTy,
55     GenericParam(GenericParamKind),
56     MacroDef,
57     Param,
58 }
59
60 impl Display for Target {
61     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
62         write!(
63             f,
64             "{}",
65             match *self {
66                 Target::ExternCrate => "extern crate",
67                 Target::Use => "use",
68                 Target::Static => "static item",
69                 Target::Const => "constant item",
70                 Target::Fn => "function",
71                 Target::Closure => "closure",
72                 Target::Mod => "module",
73                 Target::ForeignMod => "foreign module",
74                 Target::GlobalAsm => "global asm",
75                 Target::TyAlias => "type alias",
76                 Target::OpaqueTy => "opaque type",
77                 Target::Enum => "enum",
78                 Target::Variant => "enum variant",
79                 Target::Struct => "struct",
80                 Target::Field => "struct field",
81                 Target::Union => "union",
82                 Target::Trait => "trait",
83                 Target::TraitAlias => "trait alias",
84                 Target::Impl => "item",
85                 Target::Expression => "expression",
86                 Target::Statement => "statement",
87                 Target::Arm => "match arm",
88                 Target::AssocConst => "associated const",
89                 Target::Method(_) => "method",
90                 Target::AssocTy => "associated type",
91                 Target::ForeignFn => "foreign function",
92                 Target::ForeignStatic => "foreign static item",
93                 Target::ForeignTy => "foreign type",
94                 Target::GenericParam(kind) => match kind {
95                     GenericParamKind::Type => "type parameter",
96                     GenericParamKind::Lifetime => "lifetime parameter",
97                     GenericParamKind::Const => "const parameter",
98                 },
99                 Target::MacroDef => "macro def",
100                 Target::Param => "function param",
101             }
102         )
103     }
104 }
105
106 impl Target {
107     pub fn from_item(item: &Item<'_>) -> Target {
108         match item.kind {
109             ItemKind::ExternCrate(..) => Target::ExternCrate,
110             ItemKind::Use(..) => Target::Use,
111             ItemKind::Static(..) => Target::Static,
112             ItemKind::Const(..) => Target::Const,
113             ItemKind::Fn(..) => Target::Fn,
114             ItemKind::Mod(..) => Target::Mod,
115             ItemKind::ForeignMod { .. } => Target::ForeignMod,
116             ItemKind::GlobalAsm(..) => Target::GlobalAsm,
117             ItemKind::TyAlias(..) => Target::TyAlias,
118             ItemKind::OpaqueTy(..) => Target::OpaqueTy,
119             ItemKind::Enum(..) => Target::Enum,
120             ItemKind::Struct(..) => Target::Struct,
121             ItemKind::Union(..) => Target::Union,
122             ItemKind::Trait(..) => Target::Trait,
123             ItemKind::TraitAlias(..) => Target::TraitAlias,
124             ItemKind::Impl { .. } => Target::Impl,
125         }
126     }
127
128     pub fn from_trait_item(trait_item: &TraitItem<'_>) -> Target {
129         match trait_item.kind {
130             TraitItemKind::Const(..) => Target::AssocConst,
131             TraitItemKind::Fn(_, hir::TraitFn::Required(_)) => {
132                 Target::Method(MethodKind::Trait { body: false })
133             }
134             TraitItemKind::Fn(_, hir::TraitFn::Provided(_)) => {
135                 Target::Method(MethodKind::Trait { body: true })
136             }
137             TraitItemKind::Type(..) => Target::AssocTy,
138         }
139     }
140
141     pub fn from_foreign_item(foreign_item: &hir::ForeignItem<'_>) -> Target {
142         match foreign_item.kind {
143             hir::ForeignItemKind::Fn(..) => Target::ForeignFn,
144             hir::ForeignItemKind::Static(..) => Target::ForeignStatic,
145             hir::ForeignItemKind::Type => Target::ForeignTy,
146         }
147     }
148
149     pub fn from_generic_param(generic_param: &hir::GenericParam<'_>) -> Target {
150         match generic_param.kind {
151             hir::GenericParamKind::Type { .. } => Target::GenericParam(GenericParamKind::Type),
152             hir::GenericParamKind::Lifetime { .. } => {
153                 Target::GenericParam(GenericParamKind::Lifetime)
154             }
155             hir::GenericParamKind::Const { .. } => Target::GenericParam(GenericParamKind::Const),
156         }
157     }
158 }