Crate ra_ap_hir_expand

source ·
Expand description

hir_expand deals with macro expansion.

Specifically, it implements a concept of MacroFile – a file whose syntax tree originates not from the text of some FileId, but from some macro expansion.

Re-exports

Modules

  • ast_id_map
    AstIdMap allows to create stable IDs for “large” syntax nodes like items and macro calls.
  • attrs
    A higher level attributes based on TokenTree, with also some shortcuts.
  • builtin_attr_macro
    Builtin attributes.
  • builtin_derive_macro
    Builtin derives.
  • builtin_fn_macro
    Builtin macro
  • change
    Defines a unit of change that can applied to the database to get the next state. Changes are transactional.
  • db
    Defines database & queries for macro expansion.
  • eager
    Eager expansion related utils
  • files
    Things to wrap other things in file ids.
  • hygiene
    This modules handles hygiene information.
  • mod_path
    A lowering for use-paths (more generally, paths without angle-bracketed segments).
  • name
    See Name.
  • proc_macro
    Proc Macro Expander stub
  • quote
    A simplified version of quote-crate like quasi quote macro
  • span_map
    Span maps for real files and macro expansions.
  • tt

Macros

Structs

  • EagerCallInfo
  • ExpansionInfo
    ExpansionInfo mainly describes how to map text range between src and expanded macro
  • HirFileId
    Input to the analyzer is a set of files, where each file is identified by FileId and contains source code. However, another source of source code in Rust are macros: each macro can be thought of as producing a “temporary file”. To assign an id to such a file, we use the id of the macro call that produced the file. So, a HirFileId is either a FileId (source code written by user), or a MacroCallId (source code produced by macro).
  • MacroCallId
    MacroCallId identifies a particular macro invocation, like println!("Hello, {}", world).
  • MacroCallLoc
  • MacroDefId
  • MacroFileId
  • ValueResult

Enums

  • ExpandError
  • ExpandTo
    In Rust, macros expand token trees to token trees. When we want to turn a token tree into an AST node, we need to figure out what kind of AST node we want: something like foo can be a type, an expression, or a pattern.
  • MacroCallKind
  • MacroDefKind

Traits

Type Aliases