]> git.lizzy.rs Git - rust.git/blob - compiler/rustc_ast/src/ast.rs
Auto merge of #85344 - cbeuw:remap-across-cwd, r=michaelwoerister
[rust.git] / compiler / rustc_ast / src / ast.rs
1 //! The Rust abstract syntax tree module.
2 //!
3 //! This module contains common structures forming the language AST.
4 //! Two main entities in the module are [`Item`] (which represents an AST element with
5 //! additional metadata), and [`ItemKind`] (which represents a concrete type and contains
6 //! information specific to the type of the item).
7 //!
8 //! Other module items worth mentioning:
9 //! - [`Ty`] and [`TyKind`]: A parsed Rust type.
10 //! - [`Expr`] and [`ExprKind`]: A parsed Rust expression.
11 //! - [`Pat`] and [`PatKind`]: A parsed Rust pattern. Patterns are often dual to expressions.
12 //! - [`Stmt`] and [`StmtKind`]: An executable action that does not return a value.
13 //! - [`FnDecl`], [`FnHeader`] and [`Param`]: Metadata associated with a function declaration.
14 //! - [`Generics`], [`GenericParam`], [`WhereClause`]: Metadata associated with generic parameters.
15 //! - [`EnumDef`] and [`Variant`]: Enum declaration.
16 //! - [`Lit`] and [`LitKind`]: Literal expressions.
17 //! - [`MacroDef`], [`MacStmtStyle`], [`MacCall`], [`MacDelimiter`]: Macro definition and invocation.
18 //! - [`Attribute`]: Metadata associated with item.
19 //! - [`UnOp`], [`BinOp`], and [`BinOpKind`]: Unary and binary operators.
20
21 pub use crate::util::parser::ExprPrecedence;
22 pub use GenericArgs::*;
23 pub use UnsafeSource::*;
24
25 use crate::ptr::P;
26 use crate::token::{self, CommentKind, DelimToken, Token};
27 use crate::tokenstream::{DelimSpan, LazyTokenStream, TokenStream, TokenTree};
28
29 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
30 use rustc_data_structures::stack::ensure_sufficient_stack;
31 use rustc_data_structures::sync::Lrc;
32 use rustc_data_structures::thin_vec::ThinVec;
33 use rustc_macros::HashStable_Generic;
34 use rustc_serialize::{self, Decoder, Encoder};
35 use rustc_span::source_map::{respan, Spanned};
36 use rustc_span::symbol::{kw, sym, Ident, Symbol};
37 use rustc_span::{Span, DUMMY_SP};
38
39 use std::cmp::Ordering;
40 use std::convert::TryFrom;
41 use std::fmt;
42
43 #[cfg(test)]
44 mod tests;
45
46 /// A "Label" is an identifier of some point in sources,
47 /// e.g. in the following code:
48 ///
49 /// ```rust
50 /// 'outer: loop {
51 ///     break 'outer;
52 /// }
53 /// ```
54 ///
55 /// `'outer` is a label.
56 #[derive(Clone, Encodable, Decodable, Copy, HashStable_Generic)]
57 pub struct Label {
58     pub ident: Ident,
59 }
60
61 impl fmt::Debug for Label {
62     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
63         write!(f, "label({:?})", self.ident)
64     }
65 }
66
67 /// A "Lifetime" is an annotation of the scope in which variable
68 /// can be used, e.g. `'a` in `&'a i32`.
69 #[derive(Clone, Encodable, Decodable, Copy)]
70 pub struct Lifetime {
71     pub id: NodeId,
72     pub ident: Ident,
73 }
74
75 impl fmt::Debug for Lifetime {
76     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
77         write!(f, "lifetime({}: {})", self.id, self)
78     }
79 }
80
81 impl fmt::Display for Lifetime {
82     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
83         write!(f, "{}", self.ident.name)
84     }
85 }
86
87 /// A "Path" is essentially Rust's notion of a name.
88 ///
89 /// It's represented as a sequence of identifiers,
90 /// along with a bunch of supporting information.
91 ///
92 /// E.g., `std::cmp::PartialEq`.
93 #[derive(Clone, Encodable, Decodable, Debug)]
94 pub struct Path {
95     pub span: Span,
96     /// The segments in the path: the things separated by `::`.
97     /// Global paths begin with `kw::PathRoot`.
98     pub segments: Vec<PathSegment>,
99     pub tokens: Option<LazyTokenStream>,
100 }
101
102 impl PartialEq<Symbol> for Path {
103     #[inline]
104     fn eq(&self, symbol: &Symbol) -> bool {
105         self.segments.len() == 1 && { self.segments[0].ident.name == *symbol }
106     }
107 }
108
109 impl<CTX> HashStable<CTX> for Path {
110     fn hash_stable(&self, hcx: &mut CTX, hasher: &mut StableHasher) {
111         self.segments.len().hash_stable(hcx, hasher);
112         for segment in &self.segments {
113             segment.ident.name.hash_stable(hcx, hasher);
114         }
115     }
116 }
117
118 impl Path {
119     // Convert a span and an identifier to the corresponding
120     // one-segment path.
121     pub fn from_ident(ident: Ident) -> Path {
122         Path { segments: vec![PathSegment::from_ident(ident)], span: ident.span, tokens: None }
123     }
124
125     pub fn is_global(&self) -> bool {
126         !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
127     }
128 }
129
130 /// A segment of a path: an identifier, an optional lifetime, and a set of types.
131 ///
132 /// E.g., `std`, `String` or `Box<T>`.
133 #[derive(Clone, Encodable, Decodable, Debug)]
134 pub struct PathSegment {
135     /// The identifier portion of this path segment.
136     pub ident: Ident,
137
138     pub id: NodeId,
139
140     /// Type/lifetime parameters attached to this path. They come in
141     /// two flavors: `Path<A,B,C>` and `Path(A,B) -> C`.
142     /// `None` means that no parameter list is supplied (`Path`),
143     /// `Some` means that parameter list is supplied (`Path<X, Y>`)
144     /// but it can be empty (`Path<>`).
145     /// `P` is used as a size optimization for the common case with no parameters.
146     pub args: Option<P<GenericArgs>>,
147 }
148
149 impl PathSegment {
150     pub fn from_ident(ident: Ident) -> Self {
151         PathSegment { ident, id: DUMMY_NODE_ID, args: None }
152     }
153
154     pub fn path_root(span: Span) -> Self {
155         PathSegment::from_ident(Ident::new(kw::PathRoot, span))
156     }
157
158     pub fn span(&self) -> Span {
159         match &self.args {
160             Some(args) => self.ident.span.to(args.span()),
161             None => self.ident.span,
162         }
163     }
164 }
165
166 /// The arguments of a path segment.
167 ///
168 /// E.g., `<A, B>` as in `Foo<A, B>` or `(A, B)` as in `Foo(A, B)`.
169 #[derive(Clone, Encodable, Decodable, Debug)]
170 pub enum GenericArgs {
171     /// The `<'a, A, B, C>` in `foo::bar::baz::<'a, A, B, C>`.
172     AngleBracketed(AngleBracketedArgs),
173     /// The `(A, B)` and `C` in `Foo(A, B) -> C`.
174     Parenthesized(ParenthesizedArgs),
175 }
176
177 impl GenericArgs {
178     pub fn is_angle_bracketed(&self) -> bool {
179         matches!(self, AngleBracketed(..))
180     }
181
182     pub fn span(&self) -> Span {
183         match *self {
184             AngleBracketed(ref data) => data.span,
185             Parenthesized(ref data) => data.span,
186         }
187     }
188 }
189
190 /// Concrete argument in the sequence of generic args.
191 #[derive(Clone, Encodable, Decodable, Debug)]
192 pub enum GenericArg {
193     /// `'a` in `Foo<'a>`
194     Lifetime(Lifetime),
195     /// `Bar` in `Foo<Bar>`
196     Type(P<Ty>),
197     /// `1` in `Foo<1>`
198     Const(AnonConst),
199 }
200
201 impl GenericArg {
202     pub fn span(&self) -> Span {
203         match self {
204             GenericArg::Lifetime(lt) => lt.ident.span,
205             GenericArg::Type(ty) => ty.span,
206             GenericArg::Const(ct) => ct.value.span,
207         }
208     }
209 }
210
211 /// A path like `Foo<'a, T>`.
212 #[derive(Clone, Encodable, Decodable, Debug, Default)]
213 pub struct AngleBracketedArgs {
214     /// The overall span.
215     pub span: Span,
216     /// The comma separated parts in the `<...>`.
217     pub args: Vec<AngleBracketedArg>,
218 }
219
220 /// Either an argument for a parameter e.g., `'a`, `Vec<u8>`, `0`,
221 /// or a constraint on an associated item, e.g., `Item = String` or `Item: Bound`.
222 #[derive(Clone, Encodable, Decodable, Debug)]
223 pub enum AngleBracketedArg {
224     /// Argument for a generic parameter.
225     Arg(GenericArg),
226     /// Constraint for an associated item.
227     Constraint(AssocTyConstraint),
228 }
229
230 impl AngleBracketedArg {
231     pub fn span(&self) -> Span {
232         match self {
233             AngleBracketedArg::Arg(arg) => arg.span(),
234             AngleBracketedArg::Constraint(constraint) => constraint.span,
235         }
236     }
237 }
238
239 impl Into<Option<P<GenericArgs>>> for AngleBracketedArgs {
240     fn into(self) -> Option<P<GenericArgs>> {
241         Some(P(GenericArgs::AngleBracketed(self)))
242     }
243 }
244
245 impl Into<Option<P<GenericArgs>>> for ParenthesizedArgs {
246     fn into(self) -> Option<P<GenericArgs>> {
247         Some(P(GenericArgs::Parenthesized(self)))
248     }
249 }
250
251 /// A path like `Foo(A, B) -> C`.
252 #[derive(Clone, Encodable, Decodable, Debug)]
253 pub struct ParenthesizedArgs {
254     /// ```text
255     /// Foo(A, B) -> C
256     /// ^^^^^^^^^^^^^^
257     /// ```
258     pub span: Span,
259
260     /// `(A, B)`
261     pub inputs: Vec<P<Ty>>,
262
263     /// ```text
264     /// Foo(A, B) -> C
265     ///    ^^^^^^
266     /// ```
267     pub inputs_span: Span,
268
269     /// `C`
270     pub output: FnRetTy,
271 }
272
273 impl ParenthesizedArgs {
274     pub fn as_angle_bracketed_args(&self) -> AngleBracketedArgs {
275         let args = self
276             .inputs
277             .iter()
278             .cloned()
279             .map(|input| AngleBracketedArg::Arg(GenericArg::Type(input)))
280             .collect();
281         AngleBracketedArgs { span: self.inputs_span, args }
282     }
283 }
284
285 pub use crate::node_id::{NodeId, CRATE_NODE_ID, DUMMY_NODE_ID};
286
287 /// A modifier on a bound, e.g., `?Sized` or `?const Trait`.
288 ///
289 /// Negative bounds should also be handled here.
290 #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug)]
291 pub enum TraitBoundModifier {
292     /// No modifiers
293     None,
294
295     /// `?Trait`
296     Maybe,
297
298     /// `?const Trait`
299     MaybeConst,
300
301     /// `?const ?Trait`
302     //
303     // This parses but will be rejected during AST validation.
304     MaybeConstMaybe,
305 }
306
307 /// The AST represents all type param bounds as types.
308 /// `typeck::collect::compute_bounds` matches these against
309 /// the "special" built-in traits (see `middle::lang_items`) and
310 /// detects `Copy`, `Send` and `Sync`.
311 #[derive(Clone, Encodable, Decodable, Debug)]
312 pub enum GenericBound {
313     Trait(PolyTraitRef, TraitBoundModifier),
314     Outlives(Lifetime),
315 }
316
317 impl GenericBound {
318     pub fn span(&self) -> Span {
319         match self {
320             GenericBound::Trait(ref t, ..) => t.span,
321             GenericBound::Outlives(ref l) => l.ident.span,
322         }
323     }
324 }
325
326 pub type GenericBounds = Vec<GenericBound>;
327
328 /// Specifies the enforced ordering for generic parameters. In the future,
329 /// if we wanted to relax this order, we could override `PartialEq` and
330 /// `PartialOrd`, to allow the kinds to be unordered.
331 #[derive(Hash, Clone, Copy)]
332 pub enum ParamKindOrd {
333     Lifetime,
334     Type,
335     // `unordered` is only `true` if `sess.has_features().const_generics`
336     // is active. Specifically, if it's only `min_const_generics`, it will still require
337     // ordering consts after types.
338     Const { unordered: bool },
339     // `Infer` is not actually constructed directly from the AST, but is implicitly constructed
340     // during HIR lowering, and `ParamKindOrd` will implicitly order inferred variables last.
341     Infer,
342 }
343
344 impl Ord for ParamKindOrd {
345     fn cmp(&self, other: &Self) -> Ordering {
346         use ParamKindOrd::*;
347         let to_int = |v| match v {
348             Lifetime => 0,
349             Infer | Type | Const { unordered: true } => 1,
350             // technically both consts should be ordered equally,
351             // but only one is ever encountered at a time, so this is
352             // fine.
353             Const { unordered: false } => 2,
354         };
355
356         to_int(*self).cmp(&to_int(*other))
357     }
358 }
359 impl PartialOrd for ParamKindOrd {
360     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
361         Some(self.cmp(other))
362     }
363 }
364 impl PartialEq for ParamKindOrd {
365     fn eq(&self, other: &Self) -> bool {
366         self.cmp(other) == Ordering::Equal
367     }
368 }
369 impl Eq for ParamKindOrd {}
370
371 impl fmt::Display for ParamKindOrd {
372     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
373         match self {
374             ParamKindOrd::Lifetime => "lifetime".fmt(f),
375             ParamKindOrd::Type => "type".fmt(f),
376             ParamKindOrd::Const { .. } => "const".fmt(f),
377             ParamKindOrd::Infer => "infer".fmt(f),
378         }
379     }
380 }
381
382 #[derive(Clone, Encodable, Decodable, Debug)]
383 pub enum GenericParamKind {
384     /// A lifetime definition (e.g., `'a: 'b + 'c + 'd`).
385     Lifetime,
386     Type {
387         default: Option<P<Ty>>,
388     },
389     Const {
390         ty: P<Ty>,
391         /// Span of the `const` keyword.
392         kw_span: Span,
393         /// Optional default value for the const generic param
394         default: Option<AnonConst>,
395     },
396 }
397
398 #[derive(Clone, Encodable, Decodable, Debug)]
399 pub struct GenericParam {
400     pub id: NodeId,
401     pub ident: Ident,
402     pub attrs: AttrVec,
403     pub bounds: GenericBounds,
404     pub is_placeholder: bool,
405     pub kind: GenericParamKind,
406 }
407
408 /// Represents lifetime, type and const parameters attached to a declaration of
409 /// a function, enum, trait, etc.
410 #[derive(Clone, Encodable, Decodable, Debug)]
411 pub struct Generics {
412     pub params: Vec<GenericParam>,
413     pub where_clause: WhereClause,
414     pub span: Span,
415 }
416
417 impl Default for Generics {
418     /// Creates an instance of `Generics`.
419     fn default() -> Generics {
420         Generics {
421             params: Vec::new(),
422             where_clause: WhereClause {
423                 has_where_token: false,
424                 predicates: Vec::new(),
425                 span: DUMMY_SP,
426             },
427             span: DUMMY_SP,
428         }
429     }
430 }
431
432 /// A where-clause in a definition.
433 #[derive(Clone, Encodable, Decodable, Debug)]
434 pub struct WhereClause {
435     /// `true` if we ate a `where` token: this can happen
436     /// if we parsed no predicates (e.g. `struct Foo where {}`).
437     /// This allows us to accurately pretty-print
438     /// in `nt_to_tokenstream`
439     pub has_where_token: bool,
440     pub predicates: Vec<WherePredicate>,
441     pub span: Span,
442 }
443
444 /// A single predicate in a where-clause.
445 #[derive(Clone, Encodable, Decodable, Debug)]
446 pub enum WherePredicate {
447     /// A type binding (e.g., `for<'c> Foo: Send + Clone + 'c`).
448     BoundPredicate(WhereBoundPredicate),
449     /// A lifetime predicate (e.g., `'a: 'b + 'c`).
450     RegionPredicate(WhereRegionPredicate),
451     /// An equality predicate (unsupported).
452     EqPredicate(WhereEqPredicate),
453 }
454
455 impl WherePredicate {
456     pub fn span(&self) -> Span {
457         match self {
458             WherePredicate::BoundPredicate(p) => p.span,
459             WherePredicate::RegionPredicate(p) => p.span,
460             WherePredicate::EqPredicate(p) => p.span,
461         }
462     }
463 }
464
465 /// A type bound.
466 ///
467 /// E.g., `for<'c> Foo: Send + Clone + 'c`.
468 #[derive(Clone, Encodable, Decodable, Debug)]
469 pub struct WhereBoundPredicate {
470     pub span: Span,
471     /// Any generics from a `for` binding.
472     pub bound_generic_params: Vec<GenericParam>,
473     /// The type being bounded.
474     pub bounded_ty: P<Ty>,
475     /// Trait and lifetime bounds (`Clone + Send + 'static`).
476     pub bounds: GenericBounds,
477 }
478
479 /// A lifetime predicate.
480 ///
481 /// E.g., `'a: 'b + 'c`.
482 #[derive(Clone, Encodable, Decodable, Debug)]
483 pub struct WhereRegionPredicate {
484     pub span: Span,
485     pub lifetime: Lifetime,
486     pub bounds: GenericBounds,
487 }
488
489 /// An equality predicate (unsupported).
490 ///
491 /// E.g., `T = int`.
492 #[derive(Clone, Encodable, Decodable, Debug)]
493 pub struct WhereEqPredicate {
494     pub id: NodeId,
495     pub span: Span,
496     pub lhs_ty: P<Ty>,
497     pub rhs_ty: P<Ty>,
498 }
499
500 #[derive(Clone, Encodable, Decodable, Debug)]
501 pub struct Crate {
502     pub attrs: Vec<Attribute>,
503     pub items: Vec<P<Item>>,
504     pub span: Span,
505     /// The order of items in the HIR is unrelated to the order of
506     /// items in the AST. However, we generate proc macro harnesses
507     /// based on the AST order, and later refer to these harnesses
508     /// from the HIR. This field keeps track of the order in which
509     /// we generated proc macros harnesses, so that we can map
510     /// HIR proc macros items back to their harness items.
511     pub proc_macros: Vec<NodeId>,
512 }
513
514 /// Possible values inside of compile-time attribute lists.
515 ///
516 /// E.g., the '..' in `#[name(..)]`.
517 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
518 pub enum NestedMetaItem {
519     /// A full MetaItem, for recursive meta items.
520     MetaItem(MetaItem),
521     /// A literal.
522     ///
523     /// E.g., `"foo"`, `64`, `true`.
524     Literal(Lit),
525 }
526
527 /// A spanned compile-time attribute item.
528 ///
529 /// E.g., `#[test]`, `#[derive(..)]`, `#[rustfmt::skip]` or `#[feature = "foo"]`.
530 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
531 pub struct MetaItem {
532     pub path: Path,
533     pub kind: MetaItemKind,
534     pub span: Span,
535 }
536
537 /// A compile-time attribute item.
538 ///
539 /// E.g., `#[test]`, `#[derive(..)]` or `#[feature = "foo"]`.
540 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
541 pub enum MetaItemKind {
542     /// Word meta item.
543     ///
544     /// E.g., `test` as in `#[test]`.
545     Word,
546     /// List meta item.
547     ///
548     /// E.g., `derive(..)` as in `#[derive(..)]`.
549     List(Vec<NestedMetaItem>),
550     /// Name value meta item.
551     ///
552     /// E.g., `feature = "foo"` as in `#[feature = "foo"]`.
553     NameValue(Lit),
554 }
555
556 /// A block (`{ .. }`).
557 ///
558 /// E.g., `{ .. }` as in `fn foo() { .. }`.
559 #[derive(Clone, Encodable, Decodable, Debug)]
560 pub struct Block {
561     /// The statements in the block.
562     pub stmts: Vec<Stmt>,
563     pub id: NodeId,
564     /// Distinguishes between `unsafe { ... }` and `{ ... }`.
565     pub rules: BlockCheckMode,
566     pub span: Span,
567     pub tokens: Option<LazyTokenStream>,
568 }
569
570 /// A match pattern.
571 ///
572 /// Patterns appear in match statements and some other contexts, such as `let` and `if let`.
573 #[derive(Clone, Encodable, Decodable, Debug)]
574 pub struct Pat {
575     pub id: NodeId,
576     pub kind: PatKind,
577     pub span: Span,
578     pub tokens: Option<LazyTokenStream>,
579 }
580
581 impl Pat {
582     /// Attempt reparsing the pattern as a type.
583     /// This is intended for use by diagnostics.
584     pub fn to_ty(&self) -> Option<P<Ty>> {
585         let kind = match &self.kind {
586             // In a type expression `_` is an inference variable.
587             PatKind::Wild => TyKind::Infer,
588             // An IDENT pattern with no binding mode would be valid as path to a type. E.g. `u32`.
589             PatKind::Ident(BindingMode::ByValue(Mutability::Not), ident, None) => {
590                 TyKind::Path(None, Path::from_ident(*ident))
591             }
592             PatKind::Path(qself, path) => TyKind::Path(qself.clone(), path.clone()),
593             PatKind::MacCall(mac) => TyKind::MacCall(mac.clone()),
594             // `&mut? P` can be reinterpreted as `&mut? T` where `T` is `P` reparsed as a type.
595             PatKind::Ref(pat, mutbl) => {
596                 pat.to_ty().map(|ty| TyKind::Rptr(None, MutTy { ty, mutbl: *mutbl }))?
597             }
598             // A slice/array pattern `[P]` can be reparsed as `[T]`, an unsized array,
599             // when `P` can be reparsed as a type `T`.
600             PatKind::Slice(pats) if pats.len() == 1 => pats[0].to_ty().map(TyKind::Slice)?,
601             // A tuple pattern `(P0, .., Pn)` can be reparsed as `(T0, .., Tn)`
602             // assuming `T0` to `Tn` are all syntactically valid as types.
603             PatKind::Tuple(pats) => {
604                 let mut tys = Vec::with_capacity(pats.len());
605                 // FIXME(#48994) - could just be collected into an Option<Vec>
606                 for pat in pats {
607                     tys.push(pat.to_ty()?);
608                 }
609                 TyKind::Tup(tys)
610             }
611             _ => return None,
612         };
613
614         Some(P(Ty { kind, id: self.id, span: self.span, tokens: None }))
615     }
616
617     /// Walk top-down and call `it` in each place where a pattern occurs
618     /// starting with the root pattern `walk` is called on. If `it` returns
619     /// false then we will descend no further but siblings will be processed.
620     pub fn walk(&self, it: &mut impl FnMut(&Pat) -> bool) {
621         if !it(self) {
622             return;
623         }
624
625         match &self.kind {
626             // Walk into the pattern associated with `Ident` (if any).
627             PatKind::Ident(_, _, Some(p)) => p.walk(it),
628
629             // Walk into each field of struct.
630             PatKind::Struct(_, _, fields, _) => fields.iter().for_each(|field| field.pat.walk(it)),
631
632             // Sequence of patterns.
633             PatKind::TupleStruct(_, _, s)
634             | PatKind::Tuple(s)
635             | PatKind::Slice(s)
636             | PatKind::Or(s) => s.iter().for_each(|p| p.walk(it)),
637
638             // Trivial wrappers over inner patterns.
639             PatKind::Box(s) | PatKind::Ref(s, _) | PatKind::Paren(s) => s.walk(it),
640
641             // These patterns do not contain subpatterns, skip.
642             PatKind::Wild
643             | PatKind::Rest
644             | PatKind::Lit(_)
645             | PatKind::Range(..)
646             | PatKind::Ident(..)
647             | PatKind::Path(..)
648             | PatKind::MacCall(_) => {}
649         }
650     }
651
652     /// Is this a `..` pattern?
653     pub fn is_rest(&self) -> bool {
654         matches!(self.kind, PatKind::Rest)
655     }
656 }
657
658 /// A single field in a struct pattern.
659 ///
660 /// Patterns like the fields of `Foo { x, ref y, ref mut z }`
661 /// are treated the same as `x: x, y: ref y, z: ref mut z`,
662 /// except when `is_shorthand` is true.
663 #[derive(Clone, Encodable, Decodable, Debug)]
664 pub struct PatField {
665     /// The identifier for the field.
666     pub ident: Ident,
667     /// The pattern the field is destructured to.
668     pub pat: P<Pat>,
669     pub is_shorthand: bool,
670     pub attrs: AttrVec,
671     pub id: NodeId,
672     pub span: Span,
673     pub is_placeholder: bool,
674 }
675
676 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)]
677 pub enum BindingMode {
678     ByRef(Mutability),
679     ByValue(Mutability),
680 }
681
682 #[derive(Clone, Encodable, Decodable, Debug)]
683 pub enum RangeEnd {
684     /// `..=` or `...`
685     Included(RangeSyntax),
686     /// `..`
687     Excluded,
688 }
689
690 #[derive(Clone, Encodable, Decodable, Debug)]
691 pub enum RangeSyntax {
692     /// `...`
693     DotDotDot,
694     /// `..=`
695     DotDotEq,
696 }
697
698 /// All the different flavors of pattern that Rust recognizes.
699 #[derive(Clone, Encodable, Decodable, Debug)]
700 pub enum PatKind {
701     /// Represents a wildcard pattern (`_`).
702     Wild,
703
704     /// A `PatKind::Ident` may either be a new bound variable (`ref mut binding @ OPT_SUBPATTERN`),
705     /// or a unit struct/variant pattern, or a const pattern (in the last two cases the third
706     /// field must be `None`). Disambiguation cannot be done with parser alone, so it happens
707     /// during name resolution.
708     Ident(BindingMode, Ident, Option<P<Pat>>),
709
710     /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
711     /// The `bool` is `true` in the presence of a `..`.
712     Struct(Option<QSelf>, Path, Vec<PatField>, /* recovered */ bool),
713
714     /// A tuple struct/variant pattern (`Variant(x, y, .., z)`).
715     TupleStruct(Option<QSelf>, Path, Vec<P<Pat>>),
716
717     /// An or-pattern `A | B | C`.
718     /// Invariant: `pats.len() >= 2`.
719     Or(Vec<P<Pat>>),
720
721     /// A possibly qualified path pattern.
722     /// Unqualified path patterns `A::B::C` can legally refer to variants, structs, constants
723     /// or associated constants. Qualified path patterns `<A>::B::C`/`<A as Trait>::B::C` can
724     /// only legally refer to associated constants.
725     Path(Option<QSelf>, Path),
726
727     /// A tuple pattern (`(a, b)`).
728     Tuple(Vec<P<Pat>>),
729
730     /// A `box` pattern.
731     Box(P<Pat>),
732
733     /// A reference pattern (e.g., `&mut (a, b)`).
734     Ref(P<Pat>, Mutability),
735
736     /// A literal.
737     Lit(P<Expr>),
738
739     /// A range pattern (e.g., `1...2`, `1..2`, `1..`, `..2`, `1..=2`, `..=2`).
740     Range(Option<P<Expr>>, Option<P<Expr>>, Spanned<RangeEnd>),
741
742     /// A slice pattern `[a, b, c]`.
743     Slice(Vec<P<Pat>>),
744
745     /// A rest pattern `..`.
746     ///
747     /// Syntactically it is valid anywhere.
748     ///
749     /// Semantically however, it only has meaning immediately inside:
750     /// - a slice pattern: `[a, .., b]`,
751     /// - a binding pattern immediately inside a slice pattern: `[a, r @ ..]`,
752     /// - a tuple pattern: `(a, .., b)`,
753     /// - a tuple struct/variant pattern: `$path(a, .., b)`.
754     ///
755     /// In all of these cases, an additional restriction applies,
756     /// only one rest pattern may occur in the pattern sequences.
757     Rest,
758
759     /// Parentheses in patterns used for grouping (i.e., `(PAT)`).
760     Paren(P<Pat>),
761
762     /// A macro pattern; pre-expansion.
763     MacCall(MacCall),
764 }
765
766 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Copy)]
767 #[derive(HashStable_Generic, Encodable, Decodable)]
768 pub enum Mutability {
769     Mut,
770     Not,
771 }
772
773 impl Mutability {
774     pub fn invert(self) -> Self {
775         match self {
776             Mutability::Mut => Mutability::Not,
777             Mutability::Not => Mutability::Mut,
778         }
779     }
780
781     pub fn prefix_str(&self) -> &'static str {
782         match self {
783             Mutability::Mut => "mut ",
784             Mutability::Not => "",
785         }
786     }
787 }
788
789 /// The kind of borrow in an `AddrOf` expression,
790 /// e.g., `&place` or `&raw const place`.
791 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
792 #[derive(Encodable, Decodable, HashStable_Generic)]
793 pub enum BorrowKind {
794     /// A normal borrow, `&$expr` or `&mut $expr`.
795     /// The resulting type is either `&'a T` or `&'a mut T`
796     /// where `T = typeof($expr)` and `'a` is some lifetime.
797     Ref,
798     /// A raw borrow, `&raw const $expr` or `&raw mut $expr`.
799     /// The resulting type is either `*const T` or `*mut T`
800     /// where `T = typeof($expr)`.
801     Raw,
802 }
803
804 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)]
805 pub enum BinOpKind {
806     /// The `+` operator (addition)
807     Add,
808     /// The `-` operator (subtraction)
809     Sub,
810     /// The `*` operator (multiplication)
811     Mul,
812     /// The `/` operator (division)
813     Div,
814     /// The `%` operator (modulus)
815     Rem,
816     /// The `&&` operator (logical and)
817     And,
818     /// The `||` operator (logical or)
819     Or,
820     /// The `^` operator (bitwise xor)
821     BitXor,
822     /// The `&` operator (bitwise and)
823     BitAnd,
824     /// The `|` operator (bitwise or)
825     BitOr,
826     /// The `<<` operator (shift left)
827     Shl,
828     /// The `>>` operator (shift right)
829     Shr,
830     /// The `==` operator (equality)
831     Eq,
832     /// The `<` operator (less than)
833     Lt,
834     /// The `<=` operator (less than or equal to)
835     Le,
836     /// The `!=` operator (not equal to)
837     Ne,
838     /// The `>=` operator (greater than or equal to)
839     Ge,
840     /// The `>` operator (greater than)
841     Gt,
842 }
843
844 impl BinOpKind {
845     pub fn to_string(&self) -> &'static str {
846         use BinOpKind::*;
847         match *self {
848             Add => "+",
849             Sub => "-",
850             Mul => "*",
851             Div => "/",
852             Rem => "%",
853             And => "&&",
854             Or => "||",
855             BitXor => "^",
856             BitAnd => "&",
857             BitOr => "|",
858             Shl => "<<",
859             Shr => ">>",
860             Eq => "==",
861             Lt => "<",
862             Le => "<=",
863             Ne => "!=",
864             Ge => ">=",
865             Gt => ">",
866         }
867     }
868     pub fn lazy(&self) -> bool {
869         matches!(self, BinOpKind::And | BinOpKind::Or)
870     }
871
872     pub fn is_comparison(&self) -> bool {
873         use BinOpKind::*;
874         // Note for developers: please keep this as is;
875         // we want compilation to fail if another variant is added.
876         match *self {
877             Eq | Lt | Le | Ne | Gt | Ge => true,
878             And | Or | Add | Sub | Mul | Div | Rem | BitXor | BitAnd | BitOr | Shl | Shr => false,
879         }
880     }
881 }
882
883 pub type BinOp = Spanned<BinOpKind>;
884
885 /// Unary operator.
886 ///
887 /// Note that `&data` is not an operator, it's an `AddrOf` expression.
888 #[derive(Clone, Encodable, Decodable, Debug, Copy)]
889 pub enum UnOp {
890     /// The `*` operator for dereferencing
891     Deref,
892     /// The `!` operator for logical inversion
893     Not,
894     /// The `-` operator for negation
895     Neg,
896 }
897
898 impl UnOp {
899     pub fn to_string(op: UnOp) -> &'static str {
900         match op {
901             UnOp::Deref => "*",
902             UnOp::Not => "!",
903             UnOp::Neg => "-",
904         }
905     }
906 }
907
908 /// A statement
909 #[derive(Clone, Encodable, Decodable, Debug)]
910 pub struct Stmt {
911     pub id: NodeId,
912     pub kind: StmtKind,
913     pub span: Span,
914 }
915
916 impl Stmt {
917     pub fn tokens(&self) -> Option<&LazyTokenStream> {
918         match self.kind {
919             StmtKind::Local(ref local) => local.tokens.as_ref(),
920             StmtKind::Item(ref item) => item.tokens.as_ref(),
921             StmtKind::Expr(ref expr) | StmtKind::Semi(ref expr) => expr.tokens.as_ref(),
922             StmtKind::Empty => None,
923             StmtKind::MacCall(ref mac) => mac.tokens.as_ref(),
924         }
925     }
926
927     pub fn has_trailing_semicolon(&self) -> bool {
928         match &self.kind {
929             StmtKind::Semi(_) => true,
930             StmtKind::MacCall(mac) => matches!(mac.style, MacStmtStyle::Semicolon),
931             _ => false,
932         }
933     }
934
935     /// Converts a parsed `Stmt` to a `Stmt` with
936     /// a trailing semicolon.
937     ///
938     /// This only modifies the parsed AST struct, not the attached
939     /// `LazyTokenStream`. The parser is responsible for calling
940     /// `CreateTokenStream::add_trailing_semi` when there is actually
941     /// a semicolon in the tokenstream.
942     pub fn add_trailing_semicolon(mut self) -> Self {
943         self.kind = match self.kind {
944             StmtKind::Expr(expr) => StmtKind::Semi(expr),
945             StmtKind::MacCall(mac) => {
946                 StmtKind::MacCall(mac.map(|MacCallStmt { mac, style: _, attrs, tokens }| {
947                     MacCallStmt { mac, style: MacStmtStyle::Semicolon, attrs, tokens }
948                 }))
949             }
950             kind => kind,
951         };
952
953         self
954     }
955
956     pub fn is_item(&self) -> bool {
957         matches!(self.kind, StmtKind::Item(_))
958     }
959
960     pub fn is_expr(&self) -> bool {
961         matches!(self.kind, StmtKind::Expr(_))
962     }
963 }
964
965 #[derive(Clone, Encodable, Decodable, Debug)]
966 pub enum StmtKind {
967     /// A local (let) binding.
968     Local(P<Local>),
969     /// An item definition.
970     Item(P<Item>),
971     /// Expr without trailing semi-colon.
972     Expr(P<Expr>),
973     /// Expr with a trailing semi-colon.
974     Semi(P<Expr>),
975     /// Just a trailing semi-colon.
976     Empty,
977     /// Macro.
978     MacCall(P<MacCallStmt>),
979 }
980
981 #[derive(Clone, Encodable, Decodable, Debug)]
982 pub struct MacCallStmt {
983     pub mac: MacCall,
984     pub style: MacStmtStyle,
985     pub attrs: AttrVec,
986     pub tokens: Option<LazyTokenStream>,
987 }
988
989 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)]
990 pub enum MacStmtStyle {
991     /// The macro statement had a trailing semicolon (e.g., `foo! { ... };`
992     /// `foo!(...);`, `foo![...];`).
993     Semicolon,
994     /// The macro statement had braces (e.g., `foo! { ... }`).
995     Braces,
996     /// The macro statement had parentheses or brackets and no semicolon (e.g.,
997     /// `foo!(...)`). All of these will end up being converted into macro
998     /// expressions.
999     NoBraces,
1000 }
1001
1002 /// Local represents a `let` statement, e.g., `let <pat>:<ty> = <expr>;`.
1003 #[derive(Clone, Encodable, Decodable, Debug)]
1004 pub struct Local {
1005     pub id: NodeId,
1006     pub pat: P<Pat>,
1007     pub ty: Option<P<Ty>>,
1008     /// Initializer expression to set the value, if any.
1009     pub init: Option<P<Expr>>,
1010     pub span: Span,
1011     pub attrs: AttrVec,
1012     pub tokens: Option<LazyTokenStream>,
1013 }
1014
1015 /// An arm of a 'match'.
1016 ///
1017 /// E.g., `0..=10 => { println!("match!") }` as in
1018 ///
1019 /// ```
1020 /// match 123 {
1021 ///     0..=10 => { println!("match!") },
1022 ///     _ => { println!("no match!") },
1023 /// }
1024 /// ```
1025 #[derive(Clone, Encodable, Decodable, Debug)]
1026 pub struct Arm {
1027     pub attrs: AttrVec,
1028     /// Match arm pattern, e.g. `10` in `match foo { 10 => {}, _ => {} }`
1029     pub pat: P<Pat>,
1030     /// Match arm guard, e.g. `n > 10` in `match foo { n if n > 10 => {}, _ => {} }`
1031     pub guard: Option<P<Expr>>,
1032     /// Match arm body.
1033     pub body: P<Expr>,
1034     pub span: Span,
1035     pub id: NodeId,
1036     pub is_placeholder: bool,
1037 }
1038
1039 /// A single field in a struct expression, e.g. `x: value` and `y` in `Foo { x: value, y }`.
1040 #[derive(Clone, Encodable, Decodable, Debug)]
1041 pub struct ExprField {
1042     pub attrs: AttrVec,
1043     pub id: NodeId,
1044     pub span: Span,
1045     pub ident: Ident,
1046     pub expr: P<Expr>,
1047     pub is_shorthand: bool,
1048     pub is_placeholder: bool,
1049 }
1050
1051 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)]
1052 pub enum BlockCheckMode {
1053     Default,
1054     Unsafe(UnsafeSource),
1055 }
1056
1057 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy)]
1058 pub enum UnsafeSource {
1059     CompilerGenerated,
1060     UserProvided,
1061 }
1062
1063 /// A constant (expression) that's not an item or associated item,
1064 /// but needs its own `DefId` for type-checking, const-eval, etc.
1065 /// These are usually found nested inside types (e.g., array lengths)
1066 /// or expressions (e.g., repeat counts), and also used to define
1067 /// explicit discriminant values for enum variants.
1068 #[derive(Clone, Encodable, Decodable, Debug)]
1069 pub struct AnonConst {
1070     pub id: NodeId,
1071     pub value: P<Expr>,
1072 }
1073
1074 /// An expression.
1075 #[derive(Clone, Encodable, Decodable, Debug)]
1076 pub struct Expr {
1077     pub id: NodeId,
1078     pub kind: ExprKind,
1079     pub span: Span,
1080     pub attrs: AttrVec,
1081     pub tokens: Option<LazyTokenStream>,
1082 }
1083
1084 // `Expr` is used a lot. Make sure it doesn't unintentionally get bigger.
1085 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
1086 rustc_data_structures::static_assert_size!(Expr, 104);
1087
1088 impl Expr {
1089     /// Returns `true` if this expression would be valid somewhere that expects a value;
1090     /// for example, an `if` condition.
1091     pub fn returns(&self) -> bool {
1092         if let ExprKind::Block(ref block, _) = self.kind {
1093             match block.stmts.last().map(|last_stmt| &last_stmt.kind) {
1094                 // Implicit return
1095                 Some(StmtKind::Expr(_)) => true,
1096                 // Last statement is an explicit return?
1097                 Some(StmtKind::Semi(expr)) => matches!(expr.kind, ExprKind::Ret(_)),
1098                 // This is a block that doesn't end in either an implicit or explicit return.
1099                 _ => false,
1100             }
1101         } else {
1102             // This is not a block, it is a value.
1103             true
1104         }
1105     }
1106
1107     /// Is this expr either `N`, or `{ N }`.
1108     ///
1109     /// If this is not the case, name resolution does not resolve `N` when using
1110     /// `min_const_generics` as more complex expressions are not supported.
1111     pub fn is_potential_trivial_const_param(&self) -> bool {
1112         let this = if let ExprKind::Block(ref block, None) = self.kind {
1113             if block.stmts.len() == 1 {
1114                 if let StmtKind::Expr(ref expr) = block.stmts[0].kind { expr } else { self }
1115             } else {
1116                 self
1117             }
1118         } else {
1119             self
1120         };
1121
1122         if let ExprKind::Path(None, ref path) = this.kind {
1123             if path.segments.len() == 1 && path.segments[0].args.is_none() {
1124                 return true;
1125             }
1126         }
1127
1128         false
1129     }
1130
1131     pub fn to_bound(&self) -> Option<GenericBound> {
1132         match &self.kind {
1133             ExprKind::Path(None, path) => Some(GenericBound::Trait(
1134                 PolyTraitRef::new(Vec::new(), path.clone(), self.span),
1135                 TraitBoundModifier::None,
1136             )),
1137             _ => None,
1138         }
1139     }
1140
1141     pub fn peel_parens(&self) -> &Expr {
1142         let mut expr = self;
1143         while let ExprKind::Paren(inner) = &expr.kind {
1144             expr = &inner;
1145         }
1146         expr
1147     }
1148
1149     /// Attempts to reparse as `Ty` (for diagnostic purposes).
1150     pub fn to_ty(&self) -> Option<P<Ty>> {
1151         let kind = match &self.kind {
1152             // Trivial conversions.
1153             ExprKind::Path(qself, path) => TyKind::Path(qself.clone(), path.clone()),
1154             ExprKind::MacCall(mac) => TyKind::MacCall(mac.clone()),
1155
1156             ExprKind::Paren(expr) => expr.to_ty().map(TyKind::Paren)?,
1157
1158             ExprKind::AddrOf(BorrowKind::Ref, mutbl, expr) => {
1159                 expr.to_ty().map(|ty| TyKind::Rptr(None, MutTy { ty, mutbl: *mutbl }))?
1160             }
1161
1162             ExprKind::Repeat(expr, expr_len) => {
1163                 expr.to_ty().map(|ty| TyKind::Array(ty, expr_len.clone()))?
1164             }
1165
1166             ExprKind::Array(exprs) if exprs.len() == 1 => exprs[0].to_ty().map(TyKind::Slice)?,
1167
1168             ExprKind::Tup(exprs) => {
1169                 let tys = exprs.iter().map(|expr| expr.to_ty()).collect::<Option<Vec<_>>>()?;
1170                 TyKind::Tup(tys)
1171             }
1172
1173             // If binary operator is `Add` and both `lhs` and `rhs` are trait bounds,
1174             // then type of result is trait object.
1175             // Otherwise we don't assume the result type.
1176             ExprKind::Binary(binop, lhs, rhs) if binop.node == BinOpKind::Add => {
1177                 if let (Some(lhs), Some(rhs)) = (lhs.to_bound(), rhs.to_bound()) {
1178                     TyKind::TraitObject(vec![lhs, rhs], TraitObjectSyntax::None)
1179                 } else {
1180                     return None;
1181                 }
1182             }
1183
1184             // This expression doesn't look like a type syntactically.
1185             _ => return None,
1186         };
1187
1188         Some(P(Ty { kind, id: self.id, span: self.span, tokens: None }))
1189     }
1190
1191     pub fn precedence(&self) -> ExprPrecedence {
1192         match self.kind {
1193             ExprKind::Box(_) => ExprPrecedence::Box,
1194             ExprKind::Array(_) => ExprPrecedence::Array,
1195             ExprKind::ConstBlock(_) => ExprPrecedence::ConstBlock,
1196             ExprKind::Call(..) => ExprPrecedence::Call,
1197             ExprKind::MethodCall(..) => ExprPrecedence::MethodCall,
1198             ExprKind::Tup(_) => ExprPrecedence::Tup,
1199             ExprKind::Binary(op, ..) => ExprPrecedence::Binary(op.node),
1200             ExprKind::Unary(..) => ExprPrecedence::Unary,
1201             ExprKind::Lit(_) => ExprPrecedence::Lit,
1202             ExprKind::Type(..) | ExprKind::Cast(..) => ExprPrecedence::Cast,
1203             ExprKind::Let(..) => ExprPrecedence::Let,
1204             ExprKind::If(..) => ExprPrecedence::If,
1205             ExprKind::While(..) => ExprPrecedence::While,
1206             ExprKind::ForLoop(..) => ExprPrecedence::ForLoop,
1207             ExprKind::Loop(..) => ExprPrecedence::Loop,
1208             ExprKind::Match(..) => ExprPrecedence::Match,
1209             ExprKind::Closure(..) => ExprPrecedence::Closure,
1210             ExprKind::Block(..) => ExprPrecedence::Block,
1211             ExprKind::TryBlock(..) => ExprPrecedence::TryBlock,
1212             ExprKind::Async(..) => ExprPrecedence::Async,
1213             ExprKind::Await(..) => ExprPrecedence::Await,
1214             ExprKind::Assign(..) => ExprPrecedence::Assign,
1215             ExprKind::AssignOp(..) => ExprPrecedence::AssignOp,
1216             ExprKind::Field(..) => ExprPrecedence::Field,
1217             ExprKind::Index(..) => ExprPrecedence::Index,
1218             ExprKind::Range(..) => ExprPrecedence::Range,
1219             ExprKind::Underscore => ExprPrecedence::Path,
1220             ExprKind::Path(..) => ExprPrecedence::Path,
1221             ExprKind::AddrOf(..) => ExprPrecedence::AddrOf,
1222             ExprKind::Break(..) => ExprPrecedence::Break,
1223             ExprKind::Continue(..) => ExprPrecedence::Continue,
1224             ExprKind::Ret(..) => ExprPrecedence::Ret,
1225             ExprKind::InlineAsm(..) | ExprKind::LlvmInlineAsm(..) => ExprPrecedence::InlineAsm,
1226             ExprKind::MacCall(..) => ExprPrecedence::Mac,
1227             ExprKind::Struct(..) => ExprPrecedence::Struct,
1228             ExprKind::Repeat(..) => ExprPrecedence::Repeat,
1229             ExprKind::Paren(..) => ExprPrecedence::Paren,
1230             ExprKind::Try(..) => ExprPrecedence::Try,
1231             ExprKind::Yield(..) => ExprPrecedence::Yield,
1232             ExprKind::Err => ExprPrecedence::Err,
1233         }
1234     }
1235 }
1236
1237 /// Limit types of a range (inclusive or exclusive)
1238 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug)]
1239 pub enum RangeLimits {
1240     /// Inclusive at the beginning, exclusive at the end
1241     HalfOpen,
1242     /// Inclusive at the beginning and end
1243     Closed,
1244 }
1245
1246 #[derive(Clone, Encodable, Decodable, Debug)]
1247 pub enum StructRest {
1248     /// `..x`.
1249     Base(P<Expr>),
1250     /// `..`.
1251     Rest(Span),
1252     /// No trailing `..` or expression.
1253     None,
1254 }
1255
1256 #[derive(Clone, Encodable, Decodable, Debug)]
1257 pub struct StructExpr {
1258     pub qself: Option<QSelf>,
1259     pub path: Path,
1260     pub fields: Vec<ExprField>,
1261     pub rest: StructRest,
1262 }
1263
1264 #[derive(Clone, Encodable, Decodable, Debug)]
1265 pub enum ExprKind {
1266     /// A `box x` expression.
1267     Box(P<Expr>),
1268     /// An array (`[a, b, c, d]`)
1269     Array(Vec<P<Expr>>),
1270     /// Allow anonymous constants from an inline `const` block
1271     ConstBlock(AnonConst),
1272     /// A function call
1273     ///
1274     /// The first field resolves to the function itself,
1275     /// and the second field is the list of arguments.
1276     /// This also represents calling the constructor of
1277     /// tuple-like ADTs such as tuple structs and enum variants.
1278     Call(P<Expr>, Vec<P<Expr>>),
1279     /// A method call (`x.foo::<'static, Bar, Baz>(a, b, c, d)`)
1280     ///
1281     /// The `PathSegment` represents the method name and its generic arguments
1282     /// (within the angle brackets).
1283     /// The first element of the vector of an `Expr` is the expression that evaluates
1284     /// to the object on which the method is being called on (the receiver),
1285     /// and the remaining elements are the rest of the arguments.
1286     /// Thus, `x.foo::<Bar, Baz>(a, b, c, d)` is represented as
1287     /// `ExprKind::MethodCall(PathSegment { foo, [Bar, Baz] }, [x, a, b, c, d])`.
1288     /// This `Span` is the span of the function, without the dot and receiver
1289     /// (e.g. `foo(a, b)` in `x.foo(a, b)`
1290     MethodCall(PathSegment, Vec<P<Expr>>, Span),
1291     /// A tuple (e.g., `(a, b, c, d)`).
1292     Tup(Vec<P<Expr>>),
1293     /// A binary operation (e.g., `a + b`, `a * b`).
1294     Binary(BinOp, P<Expr>, P<Expr>),
1295     /// A unary operation (e.g., `!x`, `*x`).
1296     Unary(UnOp, P<Expr>),
1297     /// A literal (e.g., `1`, `"foo"`).
1298     Lit(Lit),
1299     /// A cast (e.g., `foo as f64`).
1300     Cast(P<Expr>, P<Ty>),
1301     /// A type ascription (e.g., `42: usize`).
1302     Type(P<Expr>, P<Ty>),
1303     /// A `let pat = expr` expression that is only semantically allowed in the condition
1304     /// of `if` / `while` expressions. (e.g., `if let 0 = x { .. }`).
1305     ///
1306     /// `Span` represents the whole `let pat = expr` statement.
1307     Let(P<Pat>, P<Expr>, Span),
1308     /// An `if` block, with an optional `else` block.
1309     ///
1310     /// `if expr { block } else { expr }`
1311     If(P<Expr>, P<Block>, Option<P<Expr>>),
1312     /// A while loop, with an optional label.
1313     ///
1314     /// `'label: while expr { block }`
1315     While(P<Expr>, P<Block>, Option<Label>),
1316     /// A `for` loop, with an optional label.
1317     ///
1318     /// `'label: for pat in expr { block }`
1319     ///
1320     /// This is desugared to a combination of `loop` and `match` expressions.
1321     ForLoop(P<Pat>, P<Expr>, P<Block>, Option<Label>),
1322     /// Conditionless loop (can be exited with `break`, `continue`, or `return`).
1323     ///
1324     /// `'label: loop { block }`
1325     Loop(P<Block>, Option<Label>),
1326     /// A `match` block.
1327     Match(P<Expr>, Vec<Arm>),
1328     /// A closure (e.g., `move |a, b, c| a + b + c`).
1329     ///
1330     /// The final span is the span of the argument block `|...|`.
1331     Closure(CaptureBy, Async, Movability, P<FnDecl>, P<Expr>, Span),
1332     /// A block (`'label: { ... }`).
1333     Block(P<Block>, Option<Label>),
1334     /// An async block (`async move { ... }`).
1335     ///
1336     /// The `NodeId` is the `NodeId` for the closure that results from
1337     /// desugaring an async block, just like the NodeId field in the
1338     /// `Async::Yes` variant. This is necessary in order to create a def for the
1339     /// closure which can be used as a parent of any child defs. Defs
1340     /// created during lowering cannot be made the parent of any other
1341     /// preexisting defs.
1342     Async(CaptureBy, NodeId, P<Block>),
1343     /// An await expression (`my_future.await`).
1344     Await(P<Expr>),
1345
1346     /// A try block (`try { ... }`).
1347     TryBlock(P<Block>),
1348
1349     /// An assignment (`a = foo()`).
1350     /// The `Span` argument is the span of the `=` token.
1351     Assign(P<Expr>, P<Expr>, Span),
1352     /// An assignment with an operator.
1353     ///
1354     /// E.g., `a += 1`.
1355     AssignOp(BinOp, P<Expr>, P<Expr>),
1356     /// Access of a named (e.g., `obj.foo`) or unnamed (e.g., `obj.0`) struct field.
1357     Field(P<Expr>, Ident),
1358     /// An indexing operation (e.g., `foo[2]`).
1359     Index(P<Expr>, P<Expr>),
1360     /// A range (e.g., `1..2`, `1..`, `..2`, `1..=2`, `..=2`; and `..` in destructuring assignment).
1361     Range(Option<P<Expr>>, Option<P<Expr>>, RangeLimits),
1362     /// An underscore, used in destructuring assignment to ignore a value.
1363     Underscore,
1364
1365     /// Variable reference, possibly containing `::` and/or type
1366     /// parameters (e.g., `foo::bar::<baz>`).
1367     ///
1368     /// Optionally "qualified" (e.g., `<Vec<T> as SomeTrait>::SomeType`).
1369     Path(Option<QSelf>, Path),
1370
1371     /// A referencing operation (`&a`, `&mut a`, `&raw const a` or `&raw mut a`).
1372     AddrOf(BorrowKind, Mutability, P<Expr>),
1373     /// A `break`, with an optional label to break, and an optional expression.
1374     Break(Option<Label>, Option<P<Expr>>),
1375     /// A `continue`, with an optional label.
1376     Continue(Option<Label>),
1377     /// A `return`, with an optional value to be returned.
1378     Ret(Option<P<Expr>>),
1379
1380     /// Output of the `asm!()` macro.
1381     InlineAsm(P<InlineAsm>),
1382     /// Output of the `llvm_asm!()` macro.
1383     LlvmInlineAsm(P<LlvmInlineAsm>),
1384
1385     /// A macro invocation; pre-expansion.
1386     MacCall(MacCall),
1387
1388     /// A struct literal expression.
1389     ///
1390     /// E.g., `Foo {x: 1, y: 2}`, or `Foo {x: 1, .. rest}`.
1391     Struct(P<StructExpr>),
1392
1393     /// An array literal constructed from one repeated element.
1394     ///
1395     /// E.g., `[1; 5]`. The expression is the element to be
1396     /// repeated; the constant is the number of times to repeat it.
1397     Repeat(P<Expr>, AnonConst),
1398
1399     /// No-op: used solely so we can pretty-print faithfully.
1400     Paren(P<Expr>),
1401
1402     /// A try expression (`expr?`).
1403     Try(P<Expr>),
1404
1405     /// A `yield`, with an optional value to be yielded.
1406     Yield(Option<P<Expr>>),
1407
1408     /// Placeholder for an expression that wasn't syntactically well formed in some way.
1409     Err,
1410 }
1411
1412 /// The explicit `Self` type in a "qualified path". The actual
1413 /// path, including the trait and the associated item, is stored
1414 /// separately. `position` represents the index of the associated
1415 /// item qualified with this `Self` type.
1416 ///
1417 /// ```ignore (only-for-syntax-highlight)
1418 /// <Vec<T> as a::b::Trait>::AssociatedItem
1419 ///  ^~~~~     ~~~~~~~~~~~~~~^
1420 ///  ty        position = 3
1421 ///
1422 /// <Vec<T>>::AssociatedItem
1423 ///  ^~~~~    ^
1424 ///  ty       position = 0
1425 /// ```
1426 #[derive(Clone, Encodable, Decodable, Debug)]
1427 pub struct QSelf {
1428     pub ty: P<Ty>,
1429
1430     /// The span of `a::b::Trait` in a path like `<Vec<T> as
1431     /// a::b::Trait>::AssociatedItem`; in the case where `position ==
1432     /// 0`, this is an empty span.
1433     pub path_span: Span,
1434     pub position: usize,
1435 }
1436
1437 /// A capture clause used in closures and `async` blocks.
1438 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
1439 pub enum CaptureBy {
1440     /// `move |x| y + x`.
1441     Value,
1442     /// `move` keyword was not specified.
1443     Ref,
1444 }
1445
1446 /// The movability of a generator / closure literal:
1447 /// whether a generator contains self-references, causing it to be `!Unpin`.
1448 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable, Debug, Copy)]
1449 #[derive(HashStable_Generic)]
1450 pub enum Movability {
1451     /// May contain self-references, `!Unpin`.
1452     Static,
1453     /// Must not contain self-references, `Unpin`.
1454     Movable,
1455 }
1456
1457 /// Represents a macro invocation. The `path` indicates which macro
1458 /// is being invoked, and the `args` are arguments passed to it.
1459 #[derive(Clone, Encodable, Decodable, Debug)]
1460 pub struct MacCall {
1461     pub path: Path,
1462     pub args: P<MacArgs>,
1463     pub prior_type_ascription: Option<(Span, bool)>,
1464 }
1465
1466 impl MacCall {
1467     pub fn span(&self) -> Span {
1468         self.path.span.to(self.args.span().unwrap_or(self.path.span))
1469     }
1470 }
1471
1472 /// Arguments passed to an attribute or a function-like macro.
1473 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
1474 pub enum MacArgs {
1475     /// No arguments - `#[attr]`.
1476     Empty,
1477     /// Delimited arguments - `#[attr()/[]/{}]` or `mac!()/[]/{}`.
1478     Delimited(DelimSpan, MacDelimiter, TokenStream),
1479     /// Arguments of a key-value attribute - `#[attr = "value"]`.
1480     Eq(
1481         /// Span of the `=` token.
1482         Span,
1483         /// "value" as a nonterminal token.
1484         Token,
1485     ),
1486 }
1487
1488 impl MacArgs {
1489     pub fn delim(&self) -> DelimToken {
1490         match self {
1491             MacArgs::Delimited(_, delim, _) => delim.to_token(),
1492             MacArgs::Empty | MacArgs::Eq(..) => token::NoDelim,
1493         }
1494     }
1495
1496     pub fn span(&self) -> Option<Span> {
1497         match self {
1498             MacArgs::Empty => None,
1499             MacArgs::Delimited(dspan, ..) => Some(dspan.entire()),
1500             MacArgs::Eq(eq_span, token) => Some(eq_span.to(token.span)),
1501         }
1502     }
1503
1504     /// Tokens inside the delimiters or after `=`.
1505     /// Proc macros see these tokens, for example.
1506     pub fn inner_tokens(&self) -> TokenStream {
1507         match self {
1508             MacArgs::Empty => TokenStream::default(),
1509             MacArgs::Delimited(.., tokens) => tokens.clone(),
1510             MacArgs::Eq(.., token) => TokenTree::Token(token.clone()).into(),
1511         }
1512     }
1513
1514     /// Whether a macro with these arguments needs a semicolon
1515     /// when used as a standalone item or statement.
1516     pub fn need_semicolon(&self) -> bool {
1517         !matches!(self, MacArgs::Delimited(_, MacDelimiter::Brace, _))
1518     }
1519 }
1520
1521 #[derive(Copy, Clone, PartialEq, Eq, Encodable, Decodable, Debug, HashStable_Generic)]
1522 pub enum MacDelimiter {
1523     Parenthesis,
1524     Bracket,
1525     Brace,
1526 }
1527
1528 impl MacDelimiter {
1529     pub fn to_token(self) -> DelimToken {
1530         match self {
1531             MacDelimiter::Parenthesis => DelimToken::Paren,
1532             MacDelimiter::Bracket => DelimToken::Bracket,
1533             MacDelimiter::Brace => DelimToken::Brace,
1534         }
1535     }
1536
1537     pub fn from_token(delim: DelimToken) -> Option<MacDelimiter> {
1538         match delim {
1539             token::Paren => Some(MacDelimiter::Parenthesis),
1540             token::Bracket => Some(MacDelimiter::Bracket),
1541             token::Brace => Some(MacDelimiter::Brace),
1542             token::NoDelim => None,
1543         }
1544     }
1545 }
1546
1547 /// Represents a macro definition.
1548 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
1549 pub struct MacroDef {
1550     pub body: P<MacArgs>,
1551     /// `true` if macro was defined with `macro_rules`.
1552     pub macro_rules: bool,
1553 }
1554
1555 #[derive(Clone, Encodable, Decodable, Debug, Copy, Hash, Eq, PartialEq)]
1556 #[derive(HashStable_Generic)]
1557 pub enum StrStyle {
1558     /// A regular string, like `"foo"`.
1559     Cooked,
1560     /// A raw string, like `r##"foo"##`.
1561     ///
1562     /// The value is the number of `#` symbols used.
1563     Raw(u16),
1564 }
1565
1566 /// An AST literal.
1567 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
1568 pub struct Lit {
1569     /// The original literal token as written in source code.
1570     pub token: token::Lit,
1571     /// The "semantic" representation of the literal lowered from the original tokens.
1572     /// Strings are unescaped, hexadecimal forms are eliminated, etc.
1573     /// FIXME: Remove this and only create the semantic representation during lowering to HIR.
1574     pub kind: LitKind,
1575     pub span: Span,
1576 }
1577
1578 /// Same as `Lit`, but restricted to string literals.
1579 #[derive(Clone, Copy, Encodable, Decodable, Debug)]
1580 pub struct StrLit {
1581     /// The original literal token as written in source code.
1582     pub style: StrStyle,
1583     pub symbol: Symbol,
1584     pub suffix: Option<Symbol>,
1585     pub span: Span,
1586     /// The unescaped "semantic" representation of the literal lowered from the original token.
1587     /// FIXME: Remove this and only create the semantic representation during lowering to HIR.
1588     pub symbol_unescaped: Symbol,
1589 }
1590
1591 impl StrLit {
1592     pub fn as_lit(&self) -> Lit {
1593         let token_kind = match self.style {
1594             StrStyle::Cooked => token::Str,
1595             StrStyle::Raw(n) => token::StrRaw(n),
1596         };
1597         Lit {
1598             token: token::Lit::new(token_kind, self.symbol, self.suffix),
1599             span: self.span,
1600             kind: LitKind::Str(self.symbol_unescaped, self.style),
1601         }
1602     }
1603 }
1604
1605 /// Type of the integer literal based on provided suffix.
1606 #[derive(Clone, Copy, Encodable, Decodable, Debug, Hash, Eq, PartialEq)]
1607 #[derive(HashStable_Generic)]
1608 pub enum LitIntType {
1609     /// e.g. `42_i32`.
1610     Signed(IntTy),
1611     /// e.g. `42_u32`.
1612     Unsigned(UintTy),
1613     /// e.g. `42`.
1614     Unsuffixed,
1615 }
1616
1617 /// Type of the float literal based on provided suffix.
1618 #[derive(Clone, Copy, Encodable, Decodable, Debug, Hash, Eq, PartialEq)]
1619 #[derive(HashStable_Generic)]
1620 pub enum LitFloatType {
1621     /// A float literal with a suffix (`1f32` or `1E10f32`).
1622     Suffixed(FloatTy),
1623     /// A float literal without a suffix (`1.0 or 1.0E10`).
1624     Unsuffixed,
1625 }
1626
1627 /// Literal kind.
1628 ///
1629 /// E.g., `"foo"`, `42`, `12.34`, or `bool`.
1630 #[derive(Clone, Encodable, Decodable, Debug, Hash, Eq, PartialEq, HashStable_Generic)]
1631 pub enum LitKind {
1632     /// A string literal (`"foo"`).
1633     Str(Symbol, StrStyle),
1634     /// A byte string (`b"foo"`).
1635     ByteStr(Lrc<[u8]>),
1636     /// A byte char (`b'f'`).
1637     Byte(u8),
1638     /// A character literal (`'a'`).
1639     Char(char),
1640     /// An integer literal (`1`).
1641     Int(u128, LitIntType),
1642     /// A float literal (`1f64` or `1E10f64`).
1643     Float(Symbol, LitFloatType),
1644     /// A boolean literal.
1645     Bool(bool),
1646     /// Placeholder for a literal that wasn't well-formed in some way.
1647     Err(Symbol),
1648 }
1649
1650 impl LitKind {
1651     /// Returns `true` if this literal is a string.
1652     pub fn is_str(&self) -> bool {
1653         matches!(self, LitKind::Str(..))
1654     }
1655
1656     /// Returns `true` if this literal is byte literal string.
1657     pub fn is_bytestr(&self) -> bool {
1658         matches!(self, LitKind::ByteStr(_))
1659     }
1660
1661     /// Returns `true` if this is a numeric literal.
1662     pub fn is_numeric(&self) -> bool {
1663         matches!(self, LitKind::Int(..) | LitKind::Float(..))
1664     }
1665
1666     /// Returns `true` if this literal has no suffix.
1667     /// Note: this will return true for literals with prefixes such as raw strings and byte strings.
1668     pub fn is_unsuffixed(&self) -> bool {
1669         !self.is_suffixed()
1670     }
1671
1672     /// Returns `true` if this literal has a suffix.
1673     pub fn is_suffixed(&self) -> bool {
1674         match *self {
1675             // suffixed variants
1676             LitKind::Int(_, LitIntType::Signed(..) | LitIntType::Unsigned(..))
1677             | LitKind::Float(_, LitFloatType::Suffixed(..)) => true,
1678             // unsuffixed variants
1679             LitKind::Str(..)
1680             | LitKind::ByteStr(..)
1681             | LitKind::Byte(..)
1682             | LitKind::Char(..)
1683             | LitKind::Int(_, LitIntType::Unsuffixed)
1684             | LitKind::Float(_, LitFloatType::Unsuffixed)
1685             | LitKind::Bool(..)
1686             | LitKind::Err(..) => false,
1687         }
1688     }
1689 }
1690
1691 // N.B., If you change this, you'll probably want to change the corresponding
1692 // type structure in `middle/ty.rs` as well.
1693 #[derive(Clone, Encodable, Decodable, Debug)]
1694 pub struct MutTy {
1695     pub ty: P<Ty>,
1696     pub mutbl: Mutability,
1697 }
1698
1699 /// Represents a function's signature in a trait declaration,
1700 /// trait implementation, or free function.
1701 #[derive(Clone, Encodable, Decodable, Debug)]
1702 pub struct FnSig {
1703     pub header: FnHeader,
1704     pub decl: P<FnDecl>,
1705     pub span: Span,
1706 }
1707
1708 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
1709 #[derive(Encodable, Decodable, HashStable_Generic)]
1710 pub enum FloatTy {
1711     F32,
1712     F64,
1713 }
1714
1715 impl FloatTy {
1716     pub fn name_str(self) -> &'static str {
1717         match self {
1718             FloatTy::F32 => "f32",
1719             FloatTy::F64 => "f64",
1720         }
1721     }
1722
1723     pub fn name(self) -> Symbol {
1724         match self {
1725             FloatTy::F32 => sym::f32,
1726             FloatTy::F64 => sym::f64,
1727         }
1728     }
1729 }
1730
1731 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
1732 #[derive(Encodable, Decodable, HashStable_Generic)]
1733 pub enum IntTy {
1734     Isize,
1735     I8,
1736     I16,
1737     I32,
1738     I64,
1739     I128,
1740 }
1741
1742 impl IntTy {
1743     pub fn name_str(&self) -> &'static str {
1744         match *self {
1745             IntTy::Isize => "isize",
1746             IntTy::I8 => "i8",
1747             IntTy::I16 => "i16",
1748             IntTy::I32 => "i32",
1749             IntTy::I64 => "i64",
1750             IntTy::I128 => "i128",
1751         }
1752     }
1753
1754     pub fn name(&self) -> Symbol {
1755         match *self {
1756             IntTy::Isize => sym::isize,
1757             IntTy::I8 => sym::i8,
1758             IntTy::I16 => sym::i16,
1759             IntTy::I32 => sym::i32,
1760             IntTy::I64 => sym::i64,
1761             IntTy::I128 => sym::i128,
1762         }
1763     }
1764 }
1765
1766 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Copy, Debug)]
1767 #[derive(Encodable, Decodable, HashStable_Generic)]
1768 pub enum UintTy {
1769     Usize,
1770     U8,
1771     U16,
1772     U32,
1773     U64,
1774     U128,
1775 }
1776
1777 impl UintTy {
1778     pub fn name_str(&self) -> &'static str {
1779         match *self {
1780             UintTy::Usize => "usize",
1781             UintTy::U8 => "u8",
1782             UintTy::U16 => "u16",
1783             UintTy::U32 => "u32",
1784             UintTy::U64 => "u64",
1785             UintTy::U128 => "u128",
1786         }
1787     }
1788
1789     pub fn name(&self) -> Symbol {
1790         match *self {
1791             UintTy::Usize => sym::usize,
1792             UintTy::U8 => sym::u8,
1793             UintTy::U16 => sym::u16,
1794             UintTy::U32 => sym::u32,
1795             UintTy::U64 => sym::u64,
1796             UintTy::U128 => sym::u128,
1797         }
1798     }
1799 }
1800
1801 /// A constraint on an associated type (e.g., `A = Bar` in `Foo<A = Bar>` or
1802 /// `A: TraitA + TraitB` in `Foo<A: TraitA + TraitB>`).
1803 #[derive(Clone, Encodable, Decodable, Debug)]
1804 pub struct AssocTyConstraint {
1805     pub id: NodeId,
1806     pub ident: Ident,
1807     pub gen_args: Option<GenericArgs>,
1808     pub kind: AssocTyConstraintKind,
1809     pub span: Span,
1810 }
1811
1812 /// The kinds of an `AssocTyConstraint`.
1813 #[derive(Clone, Encodable, Decodable, Debug)]
1814 pub enum AssocTyConstraintKind {
1815     /// E.g., `A = Bar` in `Foo<A = Bar>`.
1816     Equality { ty: P<Ty> },
1817     /// E.g. `A: TraitA + TraitB` in `Foo<A: TraitA + TraitB>`.
1818     Bound { bounds: GenericBounds },
1819 }
1820
1821 #[derive(Encodable, Decodable, Debug)]
1822 pub struct Ty {
1823     pub id: NodeId,
1824     pub kind: TyKind,
1825     pub span: Span,
1826     pub tokens: Option<LazyTokenStream>,
1827 }
1828
1829 impl Clone for Ty {
1830     fn clone(&self) -> Self {
1831         ensure_sufficient_stack(|| Self {
1832             id: self.id,
1833             kind: self.kind.clone(),
1834             span: self.span,
1835             tokens: self.tokens.clone(),
1836         })
1837     }
1838 }
1839
1840 impl Ty {
1841     pub fn peel_refs(&self) -> &Self {
1842         let mut final_ty = self;
1843         while let TyKind::Rptr(_, MutTy { ty, .. }) = &final_ty.kind {
1844             final_ty = &ty;
1845         }
1846         final_ty
1847     }
1848 }
1849
1850 #[derive(Clone, Encodable, Decodable, Debug)]
1851 pub struct BareFnTy {
1852     pub unsafety: Unsafe,
1853     pub ext: Extern,
1854     pub generic_params: Vec<GenericParam>,
1855     pub decl: P<FnDecl>,
1856 }
1857
1858 /// The various kinds of type recognized by the compiler.
1859 #[derive(Clone, Encodable, Decodable, Debug)]
1860 pub enum TyKind {
1861     /// A variable-length slice (`[T]`).
1862     Slice(P<Ty>),
1863     /// A fixed length array (`[T; n]`).
1864     Array(P<Ty>, AnonConst),
1865     /// A raw pointer (`*const T` or `*mut T`).
1866     Ptr(MutTy),
1867     /// A reference (`&'a T` or `&'a mut T`).
1868     Rptr(Option<Lifetime>, MutTy),
1869     /// A bare function (e.g., `fn(usize) -> bool`).
1870     BareFn(P<BareFnTy>),
1871     /// The never type (`!`).
1872     Never,
1873     /// A tuple (`(A, B, C, D,...)`).
1874     Tup(Vec<P<Ty>>),
1875     /// An anonymous struct type i.e. `struct { foo: Type }`
1876     AnonymousStruct(Vec<FieldDef>, bool),
1877     /// An anonymous union type i.e. `union { bar: Type }`
1878     AnonymousUnion(Vec<FieldDef>, bool),
1879     /// A path (`module::module::...::Type`), optionally
1880     /// "qualified", e.g., `<Vec<T> as SomeTrait>::SomeType`.
1881     ///
1882     /// Type parameters are stored in the `Path` itself.
1883     Path(Option<QSelf>, Path),
1884     /// A trait object type `Bound1 + Bound2 + Bound3`
1885     /// where `Bound` is a trait or a lifetime.
1886     TraitObject(GenericBounds, TraitObjectSyntax),
1887     /// An `impl Bound1 + Bound2 + Bound3` type
1888     /// where `Bound` is a trait or a lifetime.
1889     ///
1890     /// The `NodeId` exists to prevent lowering from having to
1891     /// generate `NodeId`s on the fly, which would complicate
1892     /// the generation of opaque `type Foo = impl Trait` items significantly.
1893     ImplTrait(NodeId, GenericBounds),
1894     /// No-op; kept solely so that we can pretty-print faithfully.
1895     Paren(P<Ty>),
1896     /// Unused for now.
1897     Typeof(AnonConst),
1898     /// This means the type should be inferred instead of it having been
1899     /// specified. This can appear anywhere in a type.
1900     Infer,
1901     /// Inferred type of a `self` or `&self` argument in a method.
1902     ImplicitSelf,
1903     /// A macro in the type position.
1904     MacCall(MacCall),
1905     /// Placeholder for a kind that has failed to be defined.
1906     Err,
1907     /// Placeholder for a `va_list`.
1908     CVarArgs,
1909 }
1910
1911 impl TyKind {
1912     pub fn is_implicit_self(&self) -> bool {
1913         matches!(self, TyKind::ImplicitSelf)
1914     }
1915
1916     pub fn is_unit(&self) -> bool {
1917         matches!(self, TyKind::Tup(tys) if tys.is_empty())
1918     }
1919 }
1920
1921 /// Syntax used to declare a trait object.
1922 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
1923 pub enum TraitObjectSyntax {
1924     Dyn,
1925     None,
1926 }
1927
1928 /// Inline assembly operand explicit register or register class.
1929 ///
1930 /// E.g., `"eax"` as in `asm!("mov eax, 2", out("eax") result)`.
1931 #[derive(Clone, Copy, Encodable, Decodable, Debug)]
1932 pub enum InlineAsmRegOrRegClass {
1933     Reg(Symbol),
1934     RegClass(Symbol),
1935 }
1936
1937 bitflags::bitflags! {
1938     #[derive(Encodable, Decodable, HashStable_Generic)]
1939     pub struct InlineAsmOptions: u8 {
1940         const PURE = 1 << 0;
1941         const NOMEM = 1 << 1;
1942         const READONLY = 1 << 2;
1943         const PRESERVES_FLAGS = 1 << 3;
1944         const NORETURN = 1 << 4;
1945         const NOSTACK = 1 << 5;
1946         const ATT_SYNTAX = 1 << 6;
1947         const RAW = 1 << 7;
1948     }
1949 }
1950
1951 #[derive(Clone, PartialEq, PartialOrd, Encodable, Decodable, Debug, Hash, HashStable_Generic)]
1952 pub enum InlineAsmTemplatePiece {
1953     String(String),
1954     Placeholder { operand_idx: usize, modifier: Option<char>, span: Span },
1955 }
1956
1957 impl fmt::Display for InlineAsmTemplatePiece {
1958     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1959         match self {
1960             Self::String(s) => {
1961                 for c in s.chars() {
1962                     match c {
1963                         '{' => f.write_str("{{")?,
1964                         '}' => f.write_str("}}")?,
1965                         _ => c.fmt(f)?,
1966                     }
1967                 }
1968                 Ok(())
1969             }
1970             Self::Placeholder { operand_idx, modifier: Some(modifier), .. } => {
1971                 write!(f, "{{{}:{}}}", operand_idx, modifier)
1972             }
1973             Self::Placeholder { operand_idx, modifier: None, .. } => {
1974                 write!(f, "{{{}}}", operand_idx)
1975             }
1976         }
1977     }
1978 }
1979
1980 impl InlineAsmTemplatePiece {
1981     /// Rebuilds the asm template string from its pieces.
1982     pub fn to_string(s: &[Self]) -> String {
1983         use fmt::Write;
1984         let mut out = String::new();
1985         for p in s.iter() {
1986             let _ = write!(out, "{}", p);
1987         }
1988         out
1989     }
1990 }
1991
1992 /// Inline assembly operand.
1993 ///
1994 /// E.g., `out("eax") result` as in `asm!("mov eax, 2", out("eax") result)`.
1995 #[derive(Clone, Encodable, Decodable, Debug)]
1996 pub enum InlineAsmOperand {
1997     In {
1998         reg: InlineAsmRegOrRegClass,
1999         expr: P<Expr>,
2000     },
2001     Out {
2002         reg: InlineAsmRegOrRegClass,
2003         late: bool,
2004         expr: Option<P<Expr>>,
2005     },
2006     InOut {
2007         reg: InlineAsmRegOrRegClass,
2008         late: bool,
2009         expr: P<Expr>,
2010     },
2011     SplitInOut {
2012         reg: InlineAsmRegOrRegClass,
2013         late: bool,
2014         in_expr: P<Expr>,
2015         out_expr: Option<P<Expr>>,
2016     },
2017     Const {
2018         anon_const: AnonConst,
2019     },
2020     Sym {
2021         expr: P<Expr>,
2022     },
2023 }
2024
2025 /// Inline assembly.
2026 ///
2027 /// E.g., `asm!("NOP");`.
2028 #[derive(Clone, Encodable, Decodable, Debug)]
2029 pub struct InlineAsm {
2030     pub template: Vec<InlineAsmTemplatePiece>,
2031     pub operands: Vec<(InlineAsmOperand, Span)>,
2032     pub clobber_abi: Option<(Symbol, Span)>,
2033     pub options: InlineAsmOptions,
2034     pub line_spans: Vec<Span>,
2035 }
2036
2037 /// Inline assembly dialect.
2038 ///
2039 /// E.g., `"intel"` as in `llvm_asm!("mov eax, 2" : "={eax}"(result) : : : "intel")`.
2040 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, Hash, HashStable_Generic)]
2041 pub enum LlvmAsmDialect {
2042     Att,
2043     Intel,
2044 }
2045
2046 /// LLVM-style inline assembly.
2047 ///
2048 /// E.g., `"={eax}"(result)` as in `llvm_asm!("mov eax, 2" : "={eax}"(result) : : : "intel")`.
2049 #[derive(Clone, Encodable, Decodable, Debug)]
2050 pub struct LlvmInlineAsmOutput {
2051     pub constraint: Symbol,
2052     pub expr: P<Expr>,
2053     pub is_rw: bool,
2054     pub is_indirect: bool,
2055 }
2056
2057 /// LLVM-style inline assembly.
2058 ///
2059 /// E.g., `llvm_asm!("NOP");`.
2060 #[derive(Clone, Encodable, Decodable, Debug)]
2061 pub struct LlvmInlineAsm {
2062     pub asm: Symbol,
2063     pub asm_str_style: StrStyle,
2064     pub outputs: Vec<LlvmInlineAsmOutput>,
2065     pub inputs: Vec<(Symbol, P<Expr>)>,
2066     pub clobbers: Vec<Symbol>,
2067     pub volatile: bool,
2068     pub alignstack: bool,
2069     pub dialect: LlvmAsmDialect,
2070 }
2071
2072 /// A parameter in a function header.
2073 ///
2074 /// E.g., `bar: usize` as in `fn foo(bar: usize)`.
2075 #[derive(Clone, Encodable, Decodable, Debug)]
2076 pub struct Param {
2077     pub attrs: AttrVec,
2078     pub ty: P<Ty>,
2079     pub pat: P<Pat>,
2080     pub id: NodeId,
2081     pub span: Span,
2082     pub is_placeholder: bool,
2083 }
2084
2085 /// Alternative representation for `Arg`s describing `self` parameter of methods.
2086 ///
2087 /// E.g., `&mut self` as in `fn foo(&mut self)`.
2088 #[derive(Clone, Encodable, Decodable, Debug)]
2089 pub enum SelfKind {
2090     /// `self`, `mut self`
2091     Value(Mutability),
2092     /// `&'lt self`, `&'lt mut self`
2093     Region(Option<Lifetime>, Mutability),
2094     /// `self: TYPE`, `mut self: TYPE`
2095     Explicit(P<Ty>, Mutability),
2096 }
2097
2098 pub type ExplicitSelf = Spanned<SelfKind>;
2099
2100 impl Param {
2101     /// Attempts to cast parameter to `ExplicitSelf`.
2102     pub fn to_self(&self) -> Option<ExplicitSelf> {
2103         if let PatKind::Ident(BindingMode::ByValue(mutbl), ident, _) = self.pat.kind {
2104             if ident.name == kw::SelfLower {
2105                 return match self.ty.kind {
2106                     TyKind::ImplicitSelf => Some(respan(self.pat.span, SelfKind::Value(mutbl))),
2107                     TyKind::Rptr(lt, MutTy { ref ty, mutbl }) if ty.kind.is_implicit_self() => {
2108                         Some(respan(self.pat.span, SelfKind::Region(lt, mutbl)))
2109                     }
2110                     _ => Some(respan(
2111                         self.pat.span.to(self.ty.span),
2112                         SelfKind::Explicit(self.ty.clone(), mutbl),
2113                     )),
2114                 };
2115             }
2116         }
2117         None
2118     }
2119
2120     /// Returns `true` if parameter is `self`.
2121     pub fn is_self(&self) -> bool {
2122         if let PatKind::Ident(_, ident, _) = self.pat.kind {
2123             ident.name == kw::SelfLower
2124         } else {
2125             false
2126         }
2127     }
2128
2129     /// Builds a `Param` object from `ExplicitSelf`.
2130     pub fn from_self(attrs: AttrVec, eself: ExplicitSelf, eself_ident: Ident) -> Param {
2131         let span = eself.span.to(eself_ident.span);
2132         let infer_ty = P(Ty { id: DUMMY_NODE_ID, kind: TyKind::ImplicitSelf, span, tokens: None });
2133         let param = |mutbl, ty| Param {
2134             attrs,
2135             pat: P(Pat {
2136                 id: DUMMY_NODE_ID,
2137                 kind: PatKind::Ident(BindingMode::ByValue(mutbl), eself_ident, None),
2138                 span,
2139                 tokens: None,
2140             }),
2141             span,
2142             ty,
2143             id: DUMMY_NODE_ID,
2144             is_placeholder: false,
2145         };
2146         match eself.node {
2147             SelfKind::Explicit(ty, mutbl) => param(mutbl, ty),
2148             SelfKind::Value(mutbl) => param(mutbl, infer_ty),
2149             SelfKind::Region(lt, mutbl) => param(
2150                 Mutability::Not,
2151                 P(Ty {
2152                     id: DUMMY_NODE_ID,
2153                     kind: TyKind::Rptr(lt, MutTy { ty: infer_ty, mutbl }),
2154                     span,
2155                     tokens: None,
2156                 }),
2157             ),
2158         }
2159     }
2160 }
2161
2162 /// A signature (not the body) of a function declaration.
2163 ///
2164 /// E.g., `fn foo(bar: baz)`.
2165 ///
2166 /// Please note that it's different from `FnHeader` structure
2167 /// which contains metadata about function safety, asyncness, constness and ABI.
2168 #[derive(Clone, Encodable, Decodable, Debug)]
2169 pub struct FnDecl {
2170     pub inputs: Vec<Param>,
2171     pub output: FnRetTy,
2172 }
2173
2174 impl FnDecl {
2175     pub fn has_self(&self) -> bool {
2176         self.inputs.get(0).map_or(false, Param::is_self)
2177     }
2178     pub fn c_variadic(&self) -> bool {
2179         self.inputs.last().map_or(false, |arg| matches!(arg.ty.kind, TyKind::CVarArgs))
2180     }
2181 }
2182
2183 /// Is the trait definition an auto trait?
2184 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
2185 pub enum IsAuto {
2186     Yes,
2187     No,
2188 }
2189
2190 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Encodable, Decodable, Debug)]
2191 #[derive(HashStable_Generic)]
2192 pub enum Unsafe {
2193     Yes(Span),
2194     No,
2195 }
2196
2197 #[derive(Copy, Clone, Encodable, Decodable, Debug)]
2198 pub enum Async {
2199     Yes { span: Span, closure_id: NodeId, return_impl_trait_id: NodeId },
2200     No,
2201 }
2202
2203 impl Async {
2204     pub fn is_async(self) -> bool {
2205         matches!(self, Async::Yes { .. })
2206     }
2207
2208     /// In this case this is an `async` return, the `NodeId` for the generated `impl Trait` item.
2209     pub fn opt_return_id(self) -> Option<NodeId> {
2210         match self {
2211             Async::Yes { return_impl_trait_id, .. } => Some(return_impl_trait_id),
2212             Async::No => None,
2213         }
2214     }
2215 }
2216
2217 #[derive(Copy, Clone, PartialEq, Eq, Hash, Encodable, Decodable, Debug)]
2218 #[derive(HashStable_Generic)]
2219 pub enum Const {
2220     Yes(Span),
2221     No,
2222 }
2223
2224 /// Item defaultness.
2225 /// For details see the [RFC #2532](https://github.com/rust-lang/rfcs/pull/2532).
2226 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
2227 pub enum Defaultness {
2228     Default(Span),
2229     Final,
2230 }
2231
2232 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, HashStable_Generic)]
2233 pub enum ImplPolarity {
2234     /// `impl Trait for Type`
2235     Positive,
2236     /// `impl !Trait for Type`
2237     Negative(Span),
2238 }
2239
2240 impl fmt::Debug for ImplPolarity {
2241     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
2242         match *self {
2243             ImplPolarity::Positive => "positive".fmt(f),
2244             ImplPolarity::Negative(_) => "negative".fmt(f),
2245         }
2246     }
2247 }
2248
2249 #[derive(Clone, Encodable, Decodable, Debug)]
2250 pub enum FnRetTy {
2251     /// Returns type is not specified.
2252     ///
2253     /// Functions default to `()` and closures default to inference.
2254     /// Span points to where return type would be inserted.
2255     Default(Span),
2256     /// Everything else.
2257     Ty(P<Ty>),
2258 }
2259
2260 impl FnRetTy {
2261     pub fn span(&self) -> Span {
2262         match *self {
2263             FnRetTy::Default(span) => span,
2264             FnRetTy::Ty(ref ty) => ty.span,
2265         }
2266     }
2267 }
2268
2269 #[derive(Clone, Copy, PartialEq, Encodable, Decodable, Debug)]
2270 pub enum Inline {
2271     Yes,
2272     No,
2273 }
2274
2275 /// Module item kind.
2276 #[derive(Clone, Encodable, Decodable, Debug)]
2277 pub enum ModKind {
2278     /// Module with inlined definition `mod foo { ... }`,
2279     /// or with definition outlined to a separate file `mod foo;` and already loaded from it.
2280     /// The inner span is from the first token past `{` to the last token until `}`,
2281     /// or from the first to the last token in the loaded file.
2282     Loaded(Vec<P<Item>>, Inline, Span),
2283     /// Module with definition outlined to a separate file `mod foo;` but not yet loaded from it.
2284     Unloaded,
2285 }
2286
2287 /// Foreign module declaration.
2288 ///
2289 /// E.g., `extern { .. }` or `extern "C" { .. }`.
2290 #[derive(Clone, Encodable, Decodable, Debug)]
2291 pub struct ForeignMod {
2292     /// `unsafe` keyword accepted syntactically for macro DSLs, but not
2293     /// semantically by Rust.
2294     pub unsafety: Unsafe,
2295     pub abi: Option<StrLit>,
2296     pub items: Vec<P<ForeignItem>>,
2297 }
2298
2299 #[derive(Clone, Encodable, Decodable, Debug)]
2300 pub struct EnumDef {
2301     pub variants: Vec<Variant>,
2302 }
2303 /// Enum variant.
2304 #[derive(Clone, Encodable, Decodable, Debug)]
2305 pub struct Variant {
2306     /// Attributes of the variant.
2307     pub attrs: AttrVec,
2308     /// Id of the variant (not the constructor, see `VariantData::ctor_id()`).
2309     pub id: NodeId,
2310     /// Span
2311     pub span: Span,
2312     /// The visibility of the variant. Syntactically accepted but not semantically.
2313     pub vis: Visibility,
2314     /// Name of the variant.
2315     pub ident: Ident,
2316
2317     /// Fields and constructor id of the variant.
2318     pub data: VariantData,
2319     /// Explicit discriminant, e.g., `Foo = 1`.
2320     pub disr_expr: Option<AnonConst>,
2321     /// Is a macro placeholder
2322     pub is_placeholder: bool,
2323 }
2324
2325 /// Part of `use` item to the right of its prefix.
2326 #[derive(Clone, Encodable, Decodable, Debug)]
2327 pub enum UseTreeKind {
2328     /// `use prefix` or `use prefix as rename`
2329     ///
2330     /// The extra `NodeId`s are for HIR lowering, when additional statements are created for each
2331     /// namespace.
2332     Simple(Option<Ident>, NodeId, NodeId),
2333     /// `use prefix::{...}`
2334     Nested(Vec<(UseTree, NodeId)>),
2335     /// `use prefix::*`
2336     Glob,
2337 }
2338
2339 /// A tree of paths sharing common prefixes.
2340 /// Used in `use` items both at top-level and inside of braces in import groups.
2341 #[derive(Clone, Encodable, Decodable, Debug)]
2342 pub struct UseTree {
2343     pub prefix: Path,
2344     pub kind: UseTreeKind,
2345     pub span: Span,
2346 }
2347
2348 impl UseTree {
2349     pub fn ident(&self) -> Ident {
2350         match self.kind {
2351             UseTreeKind::Simple(Some(rename), ..) => rename,
2352             UseTreeKind::Simple(None, ..) => {
2353                 self.prefix.segments.last().expect("empty prefix in a simple import").ident
2354             }
2355             _ => panic!("`UseTree::ident` can only be used on a simple import"),
2356         }
2357     }
2358 }
2359
2360 /// Distinguishes between `Attribute`s that decorate items and Attributes that
2361 /// are contained as statements within items. These two cases need to be
2362 /// distinguished for pretty-printing.
2363 #[derive(Clone, PartialEq, Encodable, Decodable, Debug, Copy, HashStable_Generic)]
2364 pub enum AttrStyle {
2365     Outer,
2366     Inner,
2367 }
2368
2369 rustc_index::newtype_index! {
2370     pub struct AttrId {
2371         ENCODABLE = custom
2372         DEBUG_FORMAT = "AttrId({})"
2373     }
2374 }
2375
2376 impl<S: Encoder> rustc_serialize::Encodable<S> for AttrId {
2377     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
2378         s.emit_unit()
2379     }
2380 }
2381
2382 impl<D: Decoder> rustc_serialize::Decodable<D> for AttrId {
2383     fn decode(d: &mut D) -> Result<AttrId, D::Error> {
2384         d.read_nil().map(|_| crate::attr::mk_attr_id())
2385     }
2386 }
2387
2388 #[derive(Clone, Encodable, Decodable, Debug, HashStable_Generic)]
2389 pub struct AttrItem {
2390     pub path: Path,
2391     pub args: MacArgs,
2392     pub tokens: Option<LazyTokenStream>,
2393 }
2394
2395 /// A list of attributes.
2396 pub type AttrVec = ThinVec<Attribute>;
2397
2398 /// Metadata associated with an item.
2399 #[derive(Clone, Encodable, Decodable, Debug)]
2400 pub struct Attribute {
2401     pub kind: AttrKind,
2402     pub id: AttrId,
2403     /// Denotes if the attribute decorates the following construct (outer)
2404     /// or the construct this attribute is contained within (inner).
2405     pub style: AttrStyle,
2406     pub span: Span,
2407 }
2408
2409 #[derive(Clone, Encodable, Decodable, Debug)]
2410 pub enum AttrKind {
2411     /// A normal attribute.
2412     Normal(AttrItem, Option<LazyTokenStream>),
2413
2414     /// A doc comment (e.g. `/// ...`, `//! ...`, `/** ... */`, `/*! ... */`).
2415     /// Doc attributes (e.g. `#[doc="..."]`) are represented with the `Normal`
2416     /// variant (which is much less compact and thus more expensive).
2417     DocComment(CommentKind, Symbol),
2418 }
2419
2420 /// `TraitRef`s appear in impls.
2421 ///
2422 /// Resolution maps each `TraitRef`'s `ref_id` to its defining trait; that's all
2423 /// that the `ref_id` is for. The `impl_id` maps to the "self type" of this impl.
2424 /// If this impl is an `ItemKind::Impl`, the `impl_id` is redundant (it could be the
2425 /// same as the impl's `NodeId`).
2426 #[derive(Clone, Encodable, Decodable, Debug)]
2427 pub struct TraitRef {
2428     pub path: Path,
2429     pub ref_id: NodeId,
2430 }
2431
2432 #[derive(Clone, Encodable, Decodable, Debug)]
2433 pub struct PolyTraitRef {
2434     /// The `'a` in `<'a> Foo<&'a T>`.
2435     pub bound_generic_params: Vec<GenericParam>,
2436
2437     /// The `Foo<&'a T>` in `<'a> Foo<&'a T>`.
2438     pub trait_ref: TraitRef,
2439
2440     pub span: Span,
2441 }
2442
2443 impl PolyTraitRef {
2444     pub fn new(generic_params: Vec<GenericParam>, path: Path, span: Span) -> Self {
2445         PolyTraitRef {
2446             bound_generic_params: generic_params,
2447             trait_ref: TraitRef { path, ref_id: DUMMY_NODE_ID },
2448             span,
2449         }
2450     }
2451 }
2452
2453 #[derive(Copy, Clone, Encodable, Decodable, Debug, HashStable_Generic)]
2454 pub enum CrateSugar {
2455     /// Source is `pub(crate)`.
2456     PubCrate,
2457
2458     /// Source is (just) `crate`.
2459     JustCrate,
2460 }
2461
2462 #[derive(Clone, Encodable, Decodable, Debug)]
2463 pub struct Visibility {
2464     pub kind: VisibilityKind,
2465     pub span: Span,
2466     pub tokens: Option<LazyTokenStream>,
2467 }
2468
2469 #[derive(Clone, Encodable, Decodable, Debug)]
2470 pub enum VisibilityKind {
2471     Public,
2472     Crate(CrateSugar),
2473     Restricted { path: P<Path>, id: NodeId },
2474     Inherited,
2475 }
2476
2477 impl VisibilityKind {
2478     pub fn is_pub(&self) -> bool {
2479         matches!(self, VisibilityKind::Public)
2480     }
2481 }
2482
2483 /// Field definition in a struct, variant or union.
2484 ///
2485 /// E.g., `bar: usize` as in `struct Foo { bar: usize }`.
2486 #[derive(Clone, Encodable, Decodable, Debug)]
2487 pub struct FieldDef {
2488     pub attrs: AttrVec,
2489     pub id: NodeId,
2490     pub span: Span,
2491     pub vis: Visibility,
2492     pub ident: Option<Ident>,
2493
2494     pub ty: P<Ty>,
2495     pub is_placeholder: bool,
2496 }
2497
2498 /// Fields and constructor ids of enum variants and structs.
2499 #[derive(Clone, Encodable, Decodable, Debug)]
2500 pub enum VariantData {
2501     /// Struct variant.
2502     ///
2503     /// E.g., `Bar { .. }` as in `enum Foo { Bar { .. } }`.
2504     Struct(Vec<FieldDef>, bool),
2505     /// Tuple variant.
2506     ///
2507     /// E.g., `Bar(..)` as in `enum Foo { Bar(..) }`.
2508     Tuple(Vec<FieldDef>, NodeId),
2509     /// Unit variant.
2510     ///
2511     /// E.g., `Bar = ..` as in `enum Foo { Bar = .. }`.
2512     Unit(NodeId),
2513 }
2514
2515 impl VariantData {
2516     /// Return the fields of this variant.
2517     pub fn fields(&self) -> &[FieldDef] {
2518         match *self {
2519             VariantData::Struct(ref fields, ..) | VariantData::Tuple(ref fields, _) => fields,
2520             _ => &[],
2521         }
2522     }
2523
2524     /// Return the `NodeId` of this variant's constructor, if it has one.
2525     pub fn ctor_id(&self) -> Option<NodeId> {
2526         match *self {
2527             VariantData::Struct(..) => None,
2528             VariantData::Tuple(_, id) | VariantData::Unit(id) => Some(id),
2529         }
2530     }
2531 }
2532
2533 /// An item definition.
2534 #[derive(Clone, Encodable, Decodable, Debug)]
2535 pub struct Item<K = ItemKind> {
2536     pub attrs: Vec<Attribute>,
2537     pub id: NodeId,
2538     pub span: Span,
2539     pub vis: Visibility,
2540     /// The name of the item.
2541     /// It might be a dummy name in case of anonymous items.
2542     pub ident: Ident,
2543
2544     pub kind: K,
2545
2546     /// Original tokens this item was parsed from. This isn't necessarily
2547     /// available for all items, although over time more and more items should
2548     /// have this be `Some`. Right now this is primarily used for procedural
2549     /// macros, notably custom attributes.
2550     ///
2551     /// Note that the tokens here do not include the outer attributes, but will
2552     /// include inner attributes.
2553     pub tokens: Option<LazyTokenStream>,
2554 }
2555
2556 impl Item {
2557     /// Return the span that encompasses the attributes.
2558     pub fn span_with_attributes(&self) -> Span {
2559         self.attrs.iter().fold(self.span, |acc, attr| acc.to(attr.span))
2560     }
2561 }
2562
2563 impl<K: Into<ItemKind>> Item<K> {
2564     pub fn into_item(self) -> Item {
2565         let Item { attrs, id, span, vis, ident, kind, tokens } = self;
2566         Item { attrs, id, span, vis, ident, kind: kind.into(), tokens }
2567     }
2568 }
2569
2570 /// `extern` qualifier on a function item or function type.
2571 #[derive(Clone, Copy, Encodable, Decodable, Debug)]
2572 pub enum Extern {
2573     None,
2574     Implicit,
2575     Explicit(StrLit),
2576 }
2577
2578 impl Extern {
2579     pub fn from_abi(abi: Option<StrLit>) -> Extern {
2580         abi.map_or(Extern::Implicit, Extern::Explicit)
2581     }
2582 }
2583
2584 /// A function header.
2585 ///
2586 /// All the information between the visibility and the name of the function is
2587 /// included in this struct (e.g., `async unsafe fn` or `const extern "C" fn`).
2588 #[derive(Clone, Copy, Encodable, Decodable, Debug)]
2589 pub struct FnHeader {
2590     pub unsafety: Unsafe,
2591     pub asyncness: Async,
2592     pub constness: Const,
2593     pub ext: Extern,
2594 }
2595
2596 impl FnHeader {
2597     /// Does this function header have any qualifiers or is it empty?
2598     pub fn has_qualifiers(&self) -> bool {
2599         let Self { unsafety, asyncness, constness, ext } = self;
2600         matches!(unsafety, Unsafe::Yes(_))
2601             || asyncness.is_async()
2602             || matches!(constness, Const::Yes(_))
2603             || !matches!(ext, Extern::None)
2604     }
2605 }
2606
2607 impl Default for FnHeader {
2608     fn default() -> FnHeader {
2609         FnHeader {
2610             unsafety: Unsafe::No,
2611             asyncness: Async::No,
2612             constness: Const::No,
2613             ext: Extern::None,
2614         }
2615     }
2616 }
2617
2618 #[derive(Clone, Encodable, Decodable, Debug)]
2619 pub struct TraitKind(
2620     pub IsAuto,
2621     pub Unsafe,
2622     pub Generics,
2623     pub GenericBounds,
2624     pub Vec<P<AssocItem>>,
2625 );
2626
2627 #[derive(Clone, Encodable, Decodable, Debug)]
2628 pub struct TyAliasKind(pub Defaultness, pub Generics, pub GenericBounds, pub Option<P<Ty>>);
2629
2630 #[derive(Clone, Encodable, Decodable, Debug)]
2631 pub struct ImplKind {
2632     pub unsafety: Unsafe,
2633     pub polarity: ImplPolarity,
2634     pub defaultness: Defaultness,
2635     pub constness: Const,
2636     pub generics: Generics,
2637
2638     /// The trait being implemented, if any.
2639     pub of_trait: Option<TraitRef>,
2640
2641     pub self_ty: P<Ty>,
2642     pub items: Vec<P<AssocItem>>,
2643 }
2644
2645 #[derive(Clone, Encodable, Decodable, Debug)]
2646 pub struct FnKind(pub Defaultness, pub FnSig, pub Generics, pub Option<P<Block>>);
2647
2648 #[derive(Clone, Encodable, Decodable, Debug)]
2649 pub enum ItemKind {
2650     /// An `extern crate` item, with the optional *original* crate name if the crate was renamed.
2651     ///
2652     /// E.g., `extern crate foo` or `extern crate foo_bar as foo`.
2653     ExternCrate(Option<Symbol>),
2654     /// A use declaration item (`use`).
2655     ///
2656     /// E.g., `use foo;`, `use foo::bar;` or `use foo::bar as FooBar;`.
2657     Use(UseTree),
2658     /// A static item (`static`).
2659     ///
2660     /// E.g., `static FOO: i32 = 42;` or `static FOO: &'static str = "bar";`.
2661     Static(P<Ty>, Mutability, Option<P<Expr>>),
2662     /// A constant item (`const`).
2663     ///
2664     /// E.g., `const FOO: i32 = 42;`.
2665     Const(Defaultness, P<Ty>, Option<P<Expr>>),
2666     /// A function declaration (`fn`).
2667     ///
2668     /// E.g., `fn foo(bar: usize) -> usize { .. }`.
2669     Fn(Box<FnKind>),
2670     /// A module declaration (`mod`).
2671     ///
2672     /// E.g., `mod foo;` or `mod foo { .. }`.
2673     /// `unsafe` keyword on modules is accepted syntactically for macro DSLs, but not
2674     /// semantically by Rust.
2675     Mod(Unsafe, ModKind),
2676     /// An external module (`extern`).
2677     ///
2678     /// E.g., `extern {}` or `extern "C" {}`.
2679     ForeignMod(ForeignMod),
2680     /// Module-level inline assembly (from `global_asm!()`).
2681     GlobalAsm(InlineAsm),
2682     /// A type alias (`type`).
2683     ///
2684     /// E.g., `type Foo = Bar<u8>;`.
2685     TyAlias(Box<TyAliasKind>),
2686     /// An enum definition (`enum`).
2687     ///
2688     /// E.g., `enum Foo<A, B> { C<A>, D<B> }`.
2689     Enum(EnumDef, Generics),
2690     /// A struct definition (`struct`).
2691     ///
2692     /// E.g., `struct Foo<A> { x: A }`.
2693     Struct(VariantData, Generics),
2694     /// A union definition (`union`).
2695     ///
2696     /// E.g., `union Foo<A, B> { x: A, y: B }`.
2697     Union(VariantData, Generics),
2698     /// A trait declaration (`trait`).
2699     ///
2700     /// E.g., `trait Foo { .. }`, `trait Foo<T> { .. }` or `auto trait Foo {}`.
2701     Trait(Box<TraitKind>),
2702     /// Trait alias
2703     ///
2704     /// E.g., `trait Foo = Bar + Quux;`.
2705     TraitAlias(Generics, GenericBounds),
2706     /// An implementation.
2707     ///
2708     /// E.g., `impl<A> Foo<A> { .. }` or `impl<A> Trait for Foo<A> { .. }`.
2709     Impl(Box<ImplKind>),
2710     /// A macro invocation.
2711     ///
2712     /// E.g., `foo!(..)`.
2713     MacCall(MacCall),
2714
2715     /// A macro definition.
2716     MacroDef(MacroDef),
2717 }
2718
2719 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
2720 rustc_data_structures::static_assert_size!(ItemKind, 112);
2721
2722 impl ItemKind {
2723     pub fn article(&self) -> &str {
2724         use ItemKind::*;
2725         match self {
2726             Use(..) | Static(..) | Const(..) | Fn(..) | Mod(..) | GlobalAsm(..) | TyAlias(..)
2727             | Struct(..) | Union(..) | Trait(..) | TraitAlias(..) | MacroDef(..) => "a",
2728             ExternCrate(..) | ForeignMod(..) | MacCall(..) | Enum(..) | Impl { .. } => "an",
2729         }
2730     }
2731
2732     pub fn descr(&self) -> &str {
2733         match self {
2734             ItemKind::ExternCrate(..) => "extern crate",
2735             ItemKind::Use(..) => "`use` import",
2736             ItemKind::Static(..) => "static item",
2737             ItemKind::Const(..) => "constant item",
2738             ItemKind::Fn(..) => "function",
2739             ItemKind::Mod(..) => "module",
2740             ItemKind::ForeignMod(..) => "extern block",
2741             ItemKind::GlobalAsm(..) => "global asm item",
2742             ItemKind::TyAlias(..) => "type alias",
2743             ItemKind::Enum(..) => "enum",
2744             ItemKind::Struct(..) => "struct",
2745             ItemKind::Union(..) => "union",
2746             ItemKind::Trait(..) => "trait",
2747             ItemKind::TraitAlias(..) => "trait alias",
2748             ItemKind::MacCall(..) => "item macro invocation",
2749             ItemKind::MacroDef(..) => "macro definition",
2750             ItemKind::Impl { .. } => "implementation",
2751         }
2752     }
2753
2754     pub fn generics(&self) -> Option<&Generics> {
2755         match self {
2756             Self::Fn(box FnKind(_, _, generics, _))
2757             | Self::TyAlias(box TyAliasKind(_, generics, ..))
2758             | Self::Enum(_, generics)
2759             | Self::Struct(_, generics)
2760             | Self::Union(_, generics)
2761             | Self::Trait(box TraitKind(_, _, generics, ..))
2762             | Self::TraitAlias(generics, _)
2763             | Self::Impl(box ImplKind { generics, .. }) => Some(generics),
2764             _ => None,
2765         }
2766     }
2767 }
2768
2769 /// Represents associated items.
2770 /// These include items in `impl` and `trait` definitions.
2771 pub type AssocItem = Item<AssocItemKind>;
2772
2773 /// Represents associated item kinds.
2774 ///
2775 /// The term "provided" in the variants below refers to the item having a default
2776 /// definition / body. Meanwhile, a "required" item lacks a definition / body.
2777 /// In an implementation, all items must be provided.
2778 /// The `Option`s below denote the bodies, where `Some(_)`
2779 /// means "provided" and conversely `None` means "required".
2780 #[derive(Clone, Encodable, Decodable, Debug)]
2781 pub enum AssocItemKind {
2782     /// An associated constant, `const $ident: $ty $def?;` where `def ::= "=" $expr? ;`.
2783     /// If `def` is parsed, then the constant is provided, and otherwise required.
2784     Const(Defaultness, P<Ty>, Option<P<Expr>>),
2785     /// An associated function.
2786     Fn(Box<FnKind>),
2787     /// An associated type.
2788     TyAlias(Box<TyAliasKind>),
2789     /// A macro expanding to associated items.
2790     MacCall(MacCall),
2791 }
2792
2793 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
2794 rustc_data_structures::static_assert_size!(AssocItemKind, 72);
2795
2796 impl AssocItemKind {
2797     pub fn defaultness(&self) -> Defaultness {
2798         match *self {
2799             Self::Const(def, ..)
2800             | Self::Fn(box FnKind(def, ..))
2801             | Self::TyAlias(box TyAliasKind(def, ..)) => def,
2802             Self::MacCall(..) => Defaultness::Final,
2803         }
2804     }
2805 }
2806
2807 impl From<AssocItemKind> for ItemKind {
2808     fn from(assoc_item_kind: AssocItemKind) -> ItemKind {
2809         match assoc_item_kind {
2810             AssocItemKind::Const(a, b, c) => ItemKind::Const(a, b, c),
2811             AssocItemKind::Fn(fn_kind) => ItemKind::Fn(fn_kind),
2812             AssocItemKind::TyAlias(ty_alias_kind) => ItemKind::TyAlias(ty_alias_kind),
2813             AssocItemKind::MacCall(a) => ItemKind::MacCall(a),
2814         }
2815     }
2816 }
2817
2818 impl TryFrom<ItemKind> for AssocItemKind {
2819     type Error = ItemKind;
2820
2821     fn try_from(item_kind: ItemKind) -> Result<AssocItemKind, ItemKind> {
2822         Ok(match item_kind {
2823             ItemKind::Const(a, b, c) => AssocItemKind::Const(a, b, c),
2824             ItemKind::Fn(fn_kind) => AssocItemKind::Fn(fn_kind),
2825             ItemKind::TyAlias(ty_alias_kind) => AssocItemKind::TyAlias(ty_alias_kind),
2826             ItemKind::MacCall(a) => AssocItemKind::MacCall(a),
2827             _ => return Err(item_kind),
2828         })
2829     }
2830 }
2831
2832 /// An item in `extern` block.
2833 #[derive(Clone, Encodable, Decodable, Debug)]
2834 pub enum ForeignItemKind {
2835     /// A foreign static item (`static FOO: u8`).
2836     Static(P<Ty>, Mutability, Option<P<Expr>>),
2837     /// An foreign function.
2838     Fn(Box<FnKind>),
2839     /// An foreign type.
2840     TyAlias(Box<TyAliasKind>),
2841     /// A macro expanding to foreign items.
2842     MacCall(MacCall),
2843 }
2844
2845 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
2846 rustc_data_structures::static_assert_size!(ForeignItemKind, 72);
2847
2848 impl From<ForeignItemKind> for ItemKind {
2849     fn from(foreign_item_kind: ForeignItemKind) -> ItemKind {
2850         match foreign_item_kind {
2851             ForeignItemKind::Static(a, b, c) => ItemKind::Static(a, b, c),
2852             ForeignItemKind::Fn(fn_kind) => ItemKind::Fn(fn_kind),
2853             ForeignItemKind::TyAlias(ty_alias_kind) => ItemKind::TyAlias(ty_alias_kind),
2854             ForeignItemKind::MacCall(a) => ItemKind::MacCall(a),
2855         }
2856     }
2857 }
2858
2859 impl TryFrom<ItemKind> for ForeignItemKind {
2860     type Error = ItemKind;
2861
2862     fn try_from(item_kind: ItemKind) -> Result<ForeignItemKind, ItemKind> {
2863         Ok(match item_kind {
2864             ItemKind::Static(a, b, c) => ForeignItemKind::Static(a, b, c),
2865             ItemKind::Fn(fn_kind) => ForeignItemKind::Fn(fn_kind),
2866             ItemKind::TyAlias(ty_alias_kind) => ForeignItemKind::TyAlias(ty_alias_kind),
2867             ItemKind::MacCall(a) => ForeignItemKind::MacCall(a),
2868             _ => return Err(item_kind),
2869         })
2870     }
2871 }
2872
2873 pub type ForeignItem = Item<ForeignItemKind>;