Expand description
HIR datatypes. See the rustc dev guide for more info.
Re-exports
pub use lang_items::LangItem;
pub use lang_items::LanguageItems;
pub use hir_id::*;
Modules
- arena 🔒
- For each definition, we track the following data. A definition here is defined somewhat circularly as “something with a
DefId
”, but it generally corresponds to things like structs, enums, etc. There are also some rather random cases (like const initializer expressions) that are mostly just leftovers. - hir 🔒
- HIR walker for walking the contents of nodes.
- Defines language items.
- target 🔒This module implements some validity checks for attributes. In particular it verifies that
#[inline]
and#[repr]
attributes are attached to items that actually support them and if there are conflicts between multiple such attributes attached to the same item. - Validity checking for weak lang items
Macros
- This higher-order macro declares a list of types which can be allocated by
Arena
. Note that allCopy
types can be allocated by default and need not be specified here.
Structs
- A constant (expression) that’s not an item or associated item, but needs its own
DefId
for type-checking, const-eval, etc. These are usually found nested inside types (e.g., array lengths) or expressions (e.g., repeat counts), and also used to define explicit discriminant values for enum variants. - Represents a single arm of a
match
expression, e.g.<pat> (if <guard>) => <body>
. - Attributes owned by a HIR owner.
- Explicit binding annotations given in the HIR for a binding. Note that this is not the final binding mode that we infer after type inference.
- A block of statements
{ .. }
, which may have a label (in this case thetargeted_by_break
field will betrue
) and may beunsafe
by means of therules
being anything butDefaultBlock
. - The body of a function, closure, or constant value. In the case of a function, the body contains not only the function body itself (which is an expression), but also the argument patterns, since those are something that the caller doesn’t really care about.
- An inline constant expression
const { something }
. - The top-level data structure that stores the entire contents of the crate currently being compiled.
- An expression.
- Represents the header (not the body) of a function declaration.
- Represents a function’s signature in a trait declaration, trait implementation, or a free function.
- A reference from a foreign block to one of its items. This contains the item’s ID, naturally, but also the item’s name and some other high-level details (like whether it is an associated type or method, and whether it is public). This allows other passes to find the impl they want without loading the ID (which means fewer edges in the incremental compilation graph).
- Represents lifetimes and type parameters attached to a declaration of a function, enum, trait, etc.
- Represents anything within an
impl
block. - A reference from an impl to one of its associated items. This contains the item’s ID, naturally, but also the item’s name and some other high-level details (like whether it is an associated type or method, and whether it is public). This allows other passes to find the impl they want without loading the ID (which means fewer edges in the incremental compilation graph).
- An item
- Represents a
let <pat>[: <ty>] = <expr>
expression (not a Local), occurring in anif-let
orlet-else
, evaluating to a boolean. Typically the pattern is refutable. - Represents a
let
statement (i.e.,let <pat>:<ty> = <init>;
). - Full information resulting from lowering an AST node.
- Map of all HIR nodes inside the current owner. These nodes are mapped by
ItemLocalId
alongside the index of their parent node. The HIR tree, including bodies, is pre-hashed. - Represents a parameter in a function header.
- HIR node coupled with its parent’s id in the same HIR owner.
- A single field in a struct pattern.
- A
Path
is essentially Rust’s notion of a name; for instance,std::cmp::PartialEq
. It’s represented as a sequence of identifiers, along with a bunch of supporting information. - A segment of a path: an identifier, an optional lifetime, and a set of types.
- A statement.
- Represents an item declaration within a trait declaration, possibly including a default implementation. A trait item is either required (meaning it doesn’t have an implementation, just a signature) or provided (meaning it has a default implementation).
- A reference from an trait to one of its associated items. This contains the item’s id, naturally, but also the item’s name and some other high-level details (like whether it is an associated type or method, and whether it is public). This allows other passes to find the impl they want without loading the ID (which means fewer edges in the incremental compilation graph).
- References to traits in impls.
- Bind a type to an associated type (i.e.,
A = Foo
). - A variable captured by a closure.
- A type bound (e.g.,
for<'c> Foo: Send + Clone + 'c
). - An equality predicate (e.g.,
T = int
); currently unsupported. - A lifetime predicate (e.g.,
'a: 'b + 'c
).
Enums
- In the case of a generator created as part of an async construct, which kind of async construct caused it to be created?
- The kind of borrow in an
AddrOf
expression, e.g.,&place
or&raw const place
. - A capture clause used in closures and
async
blocks. - Represents
for<...>
binder before a closure - The kind of an item that requires const-checking.
- An item within an
extern
block. - The type of source expression that caused this generator to be created.
- The AST represents all type param bounds as types.
typeck::collect::compute_bounds
matches these against the “special” built-in traits (seemiddle::lang_items
) and detectsCopy
,Send
andSync
. - Records where the generic parameter originated from.
- Represents various kinds of content within an
impl
. - Represents what type of implicit self a function has, if any.
- Is the trait definition an auto trait?
- Hints at the original code for a let statement.
- The loop type that yielded an
ExprKind::Loop
. - Hints at the original code for a
match _ { .. }
. - The movability of a generator / closure literal: whether a generator contains self-references, causing it to be
!Unpin
. - From whence the opaque type came.
- Not represented directly in the AST; referred to by name through a
ty_path
. - Represents an optionally
Self
-qualified value/type path or associated extension. - The contents of a statement.
- A modifier on a bound, currently this is only used for
?Sized
, where the modifier isMaybe
. Negative bounds should also be handled here. - Represents a trait method’s body (or just argument names).
- Represents a trait method or associated constant or type
- The various kinds of types recognized by the compiler.
- Fields and constructor IDs of enum variants and structs.
- A single predicate in a where-clause.
- The yield kind that caused an
ExprKind::Yield
.
Constants
- The name of the associated type for
Fn
return types.
Traits
- Requirements for a
StableHashingContext
to be used in this crate. This is a hack to allow using theHashStable_Generic
derive macro instead of implementing everything inrustc_middle
.
Functions
- Checks if the specified expression is a built-in range literal. (See:
LoweringContext::lower_expr()
).
Type Aliases
- A literal.
- Up to three resolutions for type, value and macro namespaces.