[][src]Crate rustc_hir

⚙️ This is an internal compiler API. (rustc_private)

This crate is being loaded from the sysroot, a permanently unstable location for private compiler dependencies. It is not intended for general use. Prefer using a public version of this crate from crates.io via Cargo.toml.

HIR datatypes. See the rustc dev guide for more info.

Re-exports

pub use hir_id::*;
pub use lang_items::LangItem;
pub use lang_items::LanguageItems;

Modules

arenaInternal
defInternal
def_idInternal
definitionsInternal

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.

hirInternal
hir_idInternal
intravisitInternal

HIR walker for walking the contents of nodes.

itemlikevisitInternal
lang_itemsInternal

Defines language items.

pat_utilInternal
stable_hash_implsInternal
targetInternal

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.

weak_lang_itemsInternal

Validity checking for weak lang items

Macros

arena_typesInternal

This declares a list of types which can be allocated by Arena.

Structs

AnonConstInternal

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.

ArmInternal

Represents a single arm of a match expression, e.g. <pat> (if <guard>) => <body>.

BareFnTyInternal
BlockInternal

A block of statements { .. }, which may have a label (in this case the targeted_by_break field will be true) and may be unsafe by means of the rules being anything but DefaultBlock.

BodyInternal

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.

BodyIdInternal
ConstArgInternal
CrateInternal

The top-level data structure that stores the entire contents of the crate currently being compiled.

CrateItemInternal

A type representing only the top-level module.

DestinationInternal
EnumDefInternal
ExprInternal

An expression.

FieldInternal
FieldPatInternal

A single field in a struct pattern.

FnDeclInternal

Represents the header (not the body) of a function declaration.

FnHeaderInternal
FnSigInternal

Represents a function's signature in a trait declaration, trait implementation, or a free function.

ForeignItemInternal
ForeignModInternal
GenericArgsInternal
GenericParamInternal
GenericParamCountInternal
GenericsInternal

Represents lifetimes and type parameters attached to a declaration of a function, enum, trait, etc.

GlobalAsmInternal
ImplItemInternal

Represents anything within an impl block.

ImplItemIdInternal
ImplItemRefInternal

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).

InlineAsmInternal
ItemInternal

An item

ItemIdInternal
LifetimeInternal
LlvmInlineAsmInternal
LlvmInlineAsmInnerInternal
LlvmInlineAsmOutputInternal
LocalInternal

Represents a let statement (i.e., let <pat>:<ty> = <expr>;).

MacroDefInternal

A macro definition, in this crate or imported from another.

ModInternal
ModuleItemsInternal
MutTyInternal
OpaqueTyInternal
ParamInternal

Represents a parameter in a function header.

PatInternal
PathInternal

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.

PathSegmentInternal

A segment of a path: an identifier, an optional lifetime, and a set of types.

PolyTraitRefInternal
StmtInternal

A statement.

StructFieldInternal
TraitCandidateInternal
TraitItemInternal

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).

TraitItemIdInternal
TraitItemRefInternal

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).

TraitRefInternal

References to traits in impls.

TyInternal
TypeBindingInternal

Bind a type to an associated type (i.e., A = Foo).

UpvarInternal

A variable captured by a closure.

VariantInternal
WhereBoundPredicateInternal

A type bound (e.g., for<'c> Foo: Send + Clone + 'c).

WhereClauseInternal

A where-clause in a definition.

WhereEqPredicateInternal

An equality predicate (e.g., T = int); currently unsupported.

WhereRegionPredicateInternal

A lifetime predicate (e.g., 'a: 'b + 'c).

Enums

AssocItemKindInternal
AsyncGeneratorKindInternal

In the case of a generator created as part of an async construct, which kind of async construct caused it to be created?

BinOpKindInternal
BindingAnnotationInternal

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.

BlockCheckModeInternal
BodyOwnerKindInternal
BorrowKindInternal

The kind of borrow in an AddrOf expression, e.g., &place or &raw const place.

CaptureByInternal

A capture clause used in closures and async blocks.

ConstContextInternal

The kind of an item that requires const-checking.

ConstnessInternal
DefaultnessInternal
ExprKindInternal
FnRetTyInternal
ForeignItemKindInternal

An item within an extern block.

GeneratorKindInternal

The type of source expression that caused this generator to be created.

GenericArgInternal
GenericBoundInternal

The AST represents all type param bounds as types. typeck::collect::compute_bounds matches these against the "special" built-in traits (see middle::lang_items) and detects Copy, Send and Sync.

GenericParamKindInternal
GuardInternal
ImplItemKindInternal

Represents various kinds of content within an impl.

ImplPolarityInternal
ImplicitSelfKindInternal

Represents what type of implicit self a function has, if any.

InlineAsmOperandInternal
IsAsyncInternal
IsAutoInternal

Is the trait definition an auto trait?

ItemKindInternal
LifetimeNameInternal
LifetimeParamKindInternal
LocalSourceInternal

Hints at the original code for a let statement.

LoopIdErrorInternal
LoopSourceInternal

The loop type that yielded an ExprKind::Loop.

MatchSourceInternal

Hints at the original code for a match _ { .. }.

MethodKindInternal
MovabilityInternal

The movability of a generator / closure literal: whether a generator contains self-references, causing it to be !Unpin.

MutabilityInternal
NodeInternal
OpaqueTyOriginInternal

From whence the opaque type came.

ParamNameInternal
PatKindInternal
PrimTyInternal

Not represented directly in the AST; referred to by name through a ty_path.

QPathInternal

Represents an optionally Self-qualified value/type path or associated extension.

RangeEndInternal
StmtKindInternal

The contents of a statement.

SyntheticTyParamKindInternal

Synthetic type parameters are converted to another form during lowering; this allows us to track the original form they had, and is useful for error messages.

TargetInternal
TraitBoundModifierInternal

A modifier on a bound, currently this is only used for ?Sized, where the modifier is Maybe. Negative bounds should also be handled here.

TraitFnInternal

Represents a trait method's body (or just argument names).

TraitItemKindInternal

Represents a trait method or associated constant or type

TyKindInternal

The various kinds of types recognized by the compiler.

TypeBindingKindInternal
UnOpInternal
UnsafeSourceInternal
UnsafetyInternal
UseKindInternal
VariantDataInternal

Fields and constructor IDs of enum variants and structs.

VisibilityKindInternal
WherePredicateInternal

A single predicate in a where-clause.

YieldSourceInternal

The yield kind that caused an ExprKind::Yield.

Constants

FN_OUTPUT_NAMEInternal

Traits

HashStableContextInternal

Requirements for a StableHashingContext to be used in this crate. This is a hack to allow using the HashStable_Generic derive macro instead of implementing everything in librustc_middle.

Functions

is_range_literalInternal

Checks if the specified expression is a built-in range literal. (See: LoweringContext::lower_expr()).

Type Definitions

BinOpInternal
CaptureModeMapInternal
GenericBoundsInternal
LitInternal

A literal.

TraitMapInternal
VisibilityInternal