Module rustc_hir::hir

source ·

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 the targeted_by_break field will be true) and may be unsafe by means of the rules being anything but DefaultBlock.
  • 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 an if-let or let-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

Constants

Functions

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

Type Aliases