Struct syntax::ext::base::ExtCtxt

pub struct ExtCtxt<'a> {
    pub parse_sess: &'a ParseSess,
    pub ecfg: ExpansionConfig<'a>,
    pub root_path: PathBuf,
    pub resolver: &'a mut dyn Resolver,
    pub current_expansion: ExpansionData,
    pub expansions: FxHashMap<Span, Vec<String>>,
}

One of these is made during expansion and incrementally updated as we go; when a macro expansion occurs, the resulting nodes have the backtrace() -> expn_data of their expansion context stored into their span.

Fields

parse_sess: &'a ParseSess

ecfg: ExpansionConfig<'a>

root_path: PathBuf

resolver: &'a mut dyn Resolver

current_expansion: ExpansionData

expansions: FxHashMap<Span, Vec<String>>

Methods

impl<'a> ExtCtxt<'a>

pub fn new(
    parse_sess: &'a ParseSess,
    ecfg: ExpansionConfig<'a>,
    resolver: &'a mut dyn Resolver
) -> ExtCtxt<'a>

pub fn expander<'b>(&'b mut self) -> MacroExpander<'b, 'a>

Returns a Folder for deeply expanding all macros in an AST node.

pub fn monotonic_expander<'b>(&'b mut self) -> MacroExpander<'b, 'a>

Returns a Folder that deeply expands all macros and assigns all NodeIds in an AST node. Once NodeIds are assigned, the node may not be expanded, removed, or otherwise modified.

pub fn new_parser_from_tts(&self, stream: TokenStream) -> Parser<'a>

pub fn source_map(&self) -> &'a SourceMap

pub fn parse_sess(&self) -> &'a ParseSess

pub fn cfg(&self) -> &CrateConfig

pub fn call_site(&self) -> Span

pub fn with_def_site_ctxt(&self, span: Span) -> Span

Equivalent of Span::def_site from the proc macro API, except that the location is taken from the span passed as an argument.

pub fn with_call_site_ctxt(&self, span: Span) -> Span

Equivalent of Span::call_site from the proc macro API, except that the location is taken from the span passed as an argument.

pub fn with_legacy_ctxt(&self, span: Span) -> Span

Span with a context reproducing macro_rules hygiene (hygienic locals, unhygienic items). FIXME: This should be eventually replaced either with with_def_site_ctxt (preferably), or with with_call_site_ctxt (where necessary).

pub fn expansion_cause(&self) -> Option<Span>

Returns span for the macro which originally caused the current expansion to happen.

Stops backtracing at include! boundary.

pub fn struct_span_warn<S: Into<MultiSpan>>(
    &self,
    sp: S,
    msg: &str
) -> DiagnosticBuilder<'a>

pub fn struct_span_err<S: Into<MultiSpan>>(
    &self,
    sp: S,
    msg: &str
) -> DiagnosticBuilder<'a>

pub fn struct_span_fatal<S: Into<MultiSpan>>(
    &self,
    sp: S,
    msg: &str
) -> DiagnosticBuilder<'a>

pub fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !

Emit msg attached to sp, and stop compilation immediately.

span_err should be strongly preferred where-ever possible: this should only be used when:

• continuing has a high risk of flow-on errors (e.g., errors in declaring a macro would cause all uses of that macro to complain about "undefined macro"), or
• there is literally nothing else that can be done (however, in most cases one can construct a dummy expression/item to substitute; we never hit resolve/type-checking so the dummy value doesn't have to match anything)

pub fn span_err<S: Into<MultiSpan>>(&self, sp: S, msg: &str)

Emit msg attached to sp, without immediately stopping compilation.

Compilation will be stopped in the near future (at the end of the macro expansion phase).

pub fn span_err_with_code<S: Into<MultiSpan>>(
    &self,
    sp: S,
    msg: &str,
    code: DiagnosticId
)

pub fn mut_span_err<S: Into<MultiSpan>>(
    &self,
    sp: S,
    msg: &str
) -> DiagnosticBuilder<'a>

pub fn span_warn<S: Into<MultiSpan>>(&self, sp: S, msg: &str)

pub fn span_unimpl<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !

pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !

pub fn trace_macros_diag(&mut self)

pub fn bug(&self, msg: &str) -> !

pub fn trace_macros(&self) -> bool

pub fn set_trace_macros(&mut self, x: bool)

pub fn ident_of(&self, st: &str) -> Ident

pub fn std_path(&self, components: &[Symbol]) -> Vec<Ident>

pub fn name_of(&self, st: &str) -> Name

pub fn check_unused_macros(&self)

pub fn resolve_path(&self, path: impl Into<PathBuf>, span: Span) -> PathBuf

Resolves a path mentioned inside Rust code.

This unifies the logic used for resolving include_X!, and #[doc(include)] file paths.

Returns an absolute path to the file that path refers to.

impl<'a> ExtCtxt<'a>

pub fn path(&self, span: Span, strs: Vec<Ident>) -> Path

pub fn path_ident(&self, span: Span, id: Ident) -> Path

pub fn path_global(&self, span: Span, strs: Vec<Ident>) -> Path

pub fn path_all(
    &self,
    span: Span,
    global: bool,
    idents: Vec<Ident>,
    args: Vec<GenericArg>,
    constraints: Vec<AssocTyConstraint>
) -> Path

pub fn qpath(
    &self,
    self_type: P<Ty>,
    trait_path: Path,
    ident: Ident
) -> (QSelf, Path)

Constructs a qualified path.

Constructs a path like <self_type as trait_path>::ident.

pub fn qpath_all(
    &self,
    self_type: P<Ty>,
    trait_path: Path,
    ident: Ident,
    args: Vec<GenericArg>,
    constraints: Vec<AssocTyConstraint>
) -> (QSelf, Path)

Constructs a qualified path.

Constructs a path like <self_type as trait_path>::ident<'a, T, A = Bar>.

pub fn ty_mt(&self, ty: P<Ty>, mutbl: Mutability) -> MutTy

pub fn ty(&self, span: Span, ty: TyKind) -> P<Ty>

pub fn ty_path(&self, path: Path) -> P<Ty>

pub fn ty_ident(&self, span: Span, ident: Ident) -> P<Ty>

pub fn anon_const(&self, span: Span, expr: ExprKind) -> AnonConst

pub fn const_ident(&self, span: Span, ident: Ident) -> AnonConst

pub fn ty_rptr(
    &self,
    span: Span,
    ty: P<Ty>,
    lifetime: Option<Lifetime>,
    mutbl: Mutability
) -> P<Ty>

pub fn ty_ptr(&self, span: Span, ty: P<Ty>, mutbl: Mutability) -> P<Ty>

pub fn ty_infer(&self, span: Span) -> P<Ty>

pub fn typaram(
    &self,
    span: Span,
    ident: Ident,
    attrs: Vec<Attribute>,
    bounds: GenericBounds,
    default: Option<P<Ty>>
) -> GenericParam

pub fn trait_ref(&self, path: Path) -> TraitRef

pub fn poly_trait_ref(&self, span: Span, path: Path) -> PolyTraitRef

pub fn trait_bound(&self, path: Path) -> GenericBound

pub fn lifetime(&self, span: Span, ident: Ident) -> Lifetime

pub fn lifetime_def(
    &self,
    span: Span,
    ident: Ident,
    attrs: Vec<Attribute>,
    bounds: GenericBounds
) -> GenericParam

pub fn stmt_expr(&self, expr: P<Expr>) -> Stmt

pub fn stmt_semi(&self, expr: P<Expr>) -> Stmt

pub fn stmt_let(&self, sp: Span, mutbl: bool, ident: Ident, ex: P<Expr>) -> Stmt

pub fn stmt_let_typed(
    &self,
    sp: Span,
    mutbl: bool,
    ident: Ident,
    typ: P<Ty>,
    ex: P<Expr>
) -> Stmt

pub fn stmt_let_type_only(&self, span: Span, ty: P<Ty>) -> Stmt

pub fn stmt_item(&self, sp: Span, item: P<Item>) -> Stmt

pub fn block_expr(&self, expr: P<Expr>) -> P<Block>

pub fn block(&self, span: Span, stmts: Vec<Stmt>) -> P<Block>

pub fn expr(&self, span: Span, node: ExprKind) -> P<Expr>

pub fn expr_path(&self, path: Path) -> P<Expr>

pub fn expr_qpath(&self, span: Span, qself: QSelf, path: Path) -> P<Expr>

Constructs a QPath expression.

pub fn expr_ident(&self, span: Span, id: Ident) -> P<Expr>

pub fn expr_self(&self, span: Span) -> P<Expr>

pub fn expr_binary(
    &self,
    sp: Span,
    op: BinOpKind,
    lhs: P<Expr>,
    rhs: P<Expr>
) -> P<Expr>

pub fn expr_deref(&self, sp: Span, e: P<Expr>) -> P<Expr>

pub fn expr_unary(&self, sp: Span, op: UnOp, e: P<Expr>) -> P<Expr>

pub fn expr_field_access(
    &self,
    sp: Span,
    expr: P<Expr>,
    ident: Ident
) -> P<Expr>

pub fn expr_tup_field_access(
    &self,
    sp: Span,
    expr: P<Expr>,
    idx: usize
) -> P<Expr>

pub fn expr_addr_of(&self, sp: Span, e: P<Expr>) -> P<Expr>

pub fn expr_mut_addr_of(&self, sp: Span, e: P<Expr>) -> P<Expr>

pub fn expr_call(
    &self,
    span: Span,
    expr: P<Expr>,
    args: Vec<P<Expr>>
) -> P<Expr>

pub fn expr_call_ident(
    &self,
    span: Span,
    id: Ident,
    args: Vec<P<Expr>>
) -> P<Expr>

pub fn expr_call_global(
    &self,
    sp: Span,
    fn_path: Vec<Ident>,
    args: Vec<P<Expr>>
) -> P<Expr>

pub fn expr_method_call(
    &self,
    span: Span,
    expr: P<Expr>,
    ident: Ident,
    args: Vec<P<Expr>>
) -> P<Expr>

pub fn expr_block(&self, b: P<Block>) -> P<Expr>

pub fn field_imm(&self, span: Span, ident: Ident, e: P<Expr>) -> Field

pub fn expr_struct(&self, span: Span, path: Path, fields: Vec<Field>) -> P<Expr>

pub fn expr_struct_ident(
    &self,
    span: Span,
    id: Ident,
    fields: Vec<Field>
) -> P<Expr>

pub fn expr_lit(&self, span: Span, lit_kind: LitKind) -> P<Expr>

pub fn expr_usize(&self, span: Span, i: usize) -> P<Expr>

pub fn expr_isize(&self, sp: Span, i: isize) -> P<Expr>

pub fn expr_u32(&self, sp: Span, u: u32) -> P<Expr>

pub fn expr_u16(&self, sp: Span, u: u16) -> P<Expr>

pub fn expr_u8(&self, sp: Span, u: u8) -> P<Expr>

pub fn expr_bool(&self, sp: Span, value: bool) -> P<Expr>

pub fn expr_vec(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>

pub fn expr_vec_ng(&self, sp: Span) -> P<Expr>

pub fn expr_vec_slice(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>

pub fn expr_str(&self, sp: Span, s: Symbol) -> P<Expr>

pub fn expr_cast(&self, sp: Span, expr: P<Expr>, ty: P<Ty>) -> P<Expr>

pub fn expr_some(&self, sp: Span, expr: P<Expr>) -> P<Expr>

pub fn expr_none(&self, sp: Span) -> P<Expr>

pub fn expr_break(&self, sp: Span) -> P<Expr>

pub fn expr_tuple(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>

pub fn expr_fail(&self, span: Span, msg: Symbol) -> P<Expr>

pub fn expr_unreachable(&self, span: Span) -> P<Expr>

pub fn expr_ok(&self, sp: Span, expr: P<Expr>) -> P<Expr>

pub fn expr_err(&self, sp: Span, expr: P<Expr>) -> P<Expr>

pub fn expr_try(&self, sp: Span, head: P<Expr>) -> P<Expr>

pub fn pat(&self, span: Span, pat: PatKind) -> P<Pat>

pub fn pat_wild(&self, span: Span) -> P<Pat>

pub fn pat_lit(&self, span: Span, expr: P<Expr>) -> P<Pat>

pub fn pat_ident(&self, span: Span, ident: Ident) -> P<Pat>

pub fn pat_ident_binding_mode(
    &self,
    span: Span,
    ident: Ident,
    bm: BindingMode
) -> P<Pat>

pub fn pat_path(&self, span: Span, path: Path) -> P<Pat>

pub fn pat_tuple_struct(
    &self,
    span: Span,
    path: Path,
    subpats: Vec<P<Pat>>
) -> P<Pat>

pub fn pat_struct(
    &self,
    span: Span,
    path: Path,
    field_pats: Vec<FieldPat>
) -> P<Pat>

pub fn pat_tuple(&self, span: Span, pats: Vec<P<Pat>>) -> P<Pat>

pub fn pat_some(&self, span: Span, pat: P<Pat>) -> P<Pat>

pub fn pat_none(&self, span: Span) -> P<Pat>

pub fn pat_ok(&self, span: Span, pat: P<Pat>) -> P<Pat>

pub fn pat_err(&self, span: Span, pat: P<Pat>) -> P<Pat>

pub fn arm(&self, span: Span, pat: P<Pat>, expr: P<Expr>) -> Arm

pub fn arm_unreachable(&self, span: Span) -> Arm

pub fn expr_match(&self, span: Span, arg: P<Expr>, arms: Vec<Arm>) -> P<Expr>

pub fn expr_if(
    &self,
    span: Span,
    cond: P<Expr>,
    then: P<Expr>,
    els: Option<P<Expr>>
) -> P<Expr>

pub fn expr_loop(&self, span: Span, block: P<Block>) -> P<Expr>

pub fn lambda_fn_decl(
    &self,
    span: Span,
    fn_decl: P<FnDecl>,
    body: P<Expr>,
    fn_decl_span: Span
) -> P<Expr>

pub fn lambda(&self, span: Span, ids: Vec<Ident>, body: P<Expr>) -> P<Expr>

pub fn lambda0(&self, span: Span, body: P<Expr>) -> P<Expr>

pub fn lambda1(&self, span: Span, body: P<Expr>, ident: Ident) -> P<Expr>

pub fn lambda_stmts(
    &self,
    span: Span,
    ids: Vec<Ident>,
    stmts: Vec<Stmt>
) -> P<Expr>

pub fn lambda_stmts_0(&self, span: Span, stmts: Vec<Stmt>) -> P<Expr>

pub fn lambda_stmts_1(
    &self,
    span: Span,
    stmts: Vec<Stmt>,
    ident: Ident
) -> P<Expr>

pub fn param(&self, span: Span, ident: Ident, ty: P<Ty>) -> Param

pub fn fn_decl(&self, inputs: Vec<Param>, output: FunctionRetTy) -> P<FnDecl>

pub fn item(
    &self,
    span: Span,
    name: Ident,
    attrs: Vec<Attribute>,
    node: ItemKind
) -> P<Item>

pub fn item_fn_poly(
    &self,
    span: Span,
    name: Ident,
    inputs: Vec<Param>,
    output: P<Ty>,
    generics: Generics,
    body: P<Block>
) -> P<Item>

pub fn item_fn(
    &self,
    span: Span,
    name: Ident,
    inputs: Vec<Param>,
    output: P<Ty>,
    body: P<Block>
) -> P<Item>

pub fn variant(&self, span: Span, ident: Ident, tys: Vec<P<Ty>>) -> Variant

pub fn item_enum_poly(
    &self,
    span: Span,
    name: Ident,
    enum_definition: EnumDef,
    generics: Generics
) -> P<Item>

pub fn item_enum(
    &self,
    span: Span,
    name: Ident,
    enum_definition: EnumDef
) -> P<Item>

pub fn item_struct(
    &self,
    span: Span,
    name: Ident,
    struct_def: VariantData
) -> P<Item>

pub fn item_struct_poly(
    &self,
    span: Span,
    name: Ident,
    struct_def: VariantData,
    generics: Generics
) -> P<Item>

pub fn item_mod(
    &self,
    span: Span,
    inner_span: Span,
    name: Ident,
    attrs: Vec<Attribute>,
    items: Vec<P<Item>>
) -> P<Item>

pub fn item_extern_crate(&self, span: Span, name: Ident) -> P<Item>

pub fn item_static(
    &self,
    span: Span,
    name: Ident,
    ty: P<Ty>,
    mutbl: Mutability,
    expr: P<Expr>
) -> P<Item>

pub fn item_const(
    &self,
    span: Span,
    name: Ident,
    ty: P<Ty>,
    expr: P<Expr>
) -> P<Item>

pub fn item_ty_poly(
    &self,
    span: Span,
    name: Ident,
    ty: P<Ty>,
    generics: Generics
) -> P<Item>

pub fn item_ty(&self, span: Span, name: Ident, ty: P<Ty>) -> P<Item>

pub fn attribute(&self, mi: MetaItem) -> Attribute

pub fn meta_word(&self, sp: Span, w: Name) -> MetaItem

pub fn meta_list_item_word(&self, sp: Span, w: Name) -> NestedMetaItem

pub fn meta_list(
    &self,
    sp: Span,
    name: Name,
    mis: Vec<NestedMetaItem>
) -> MetaItem

pub fn meta_name_value(
    &self,
    span: Span,
    name: Name,
    lit_kind: LitKind
) -> MetaItem

pub fn item_use(&self, sp: Span, vis: Visibility, vp: P<UseTree>) -> P<Item>

pub fn item_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> P<Item>

pub fn item_use_simple_(
    &self,
    sp: Span,
    vis: Visibility,
    rename: Option<Ident>,
    path: Path
) -> P<Item>

pub fn item_use_list(
    &self,
    sp: Span,
    vis: Visibility,
    path: Vec<Ident>,
    imports: &[Ident]
) -> P<Item>

pub fn item_use_glob(
    &self,
    sp: Span,
    vis: Visibility,
    path: Vec<Ident>
) -> P<Item>