Struct syntex_syntax::ext::base::ExtCtxt [−] [src]

pub struct ExtCtxt<'a> {
    pub parse_sess: &'a ParseSess,
    pub cfg: CrateConfig,
    pub backtrace: ExpnId,
    pub ecfg: ExpansionConfig<'a>,
    pub crate_root: Option<&'static str>,
    pub feature_gated_cfgs: &'a mut Vec<GatedCfgAttr>,
    pub mod_path: Vec<Ident>,
    pub exported_macros: Vec<MacroDef>,
    pub syntax_env: SyntaxEnv,
    pub recursion_count: usize,
}

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_info of their expansion context stored into their span.

Fields

`parse_sess`
`cfg`
`backtrace`
`ecfg`
`crate_root`
`feature_gated_cfgs`
`mod_path`
`exported_macros`
`syntax_env`
`recursion_count`

Methods

`impl<'a> ExtCtxt<'a>`

`fn new(parse_sess: &'a ParseSess, cfg: CrateConfig, ecfg: ExpansionConfig<'a>, feature_gated_cfgs: &'a mut Vec<GatedCfgAttr>) -> ExtCtxt<'a>`

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

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

`fn new_parser_from_tts(&self, tts: &[TokenTree]) -> Parser<'a>`

`fn codemap(&self) -> &'a CodeMap`

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

`fn cfg(&self) -> CrateConfig`

`fn call_site(&self) -> Span`

`fn backtrace(&self) -> ExpnId`

`fn original_span(&self) -> Span`

Original span that caused the current exapnsion to happen.

`fn expansion_cause(&self) -> Span`

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

Stops backtracing at include! boundary.

`fn mod_push(&mut self, i: Ident)`

`fn mod_pop(&mut self)`

`fn mod_path(&self) -> Vec<Ident>`

`fn bt_push(&mut self, ei: ExpnInfo)`

`fn bt_pop(&mut self)`

`fn insert_macro(&mut self, def: MacroDef)`

`fn span_fatal(&self, sp: Span, 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)

`fn span_err(&self, sp: Span, 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).

`fn span_warn(&self, sp: Span, msg: &str)`

`fn span_unimpl(&self, sp: Span, msg: &str) -> !`

`fn span_bug(&self, sp: Span, msg: &str) -> !`

`fn span_note(&self, sp: Span, msg: &str)`

`fn span_help(&self, sp: Span, msg: &str)`

`fn fileline_help(&self, sp: Span, msg: &str)`

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

`fn trace_macros(&self) -> bool`

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

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

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

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

`fn suggest_macro_name(&mut self, name: &str, span: Span)`

Trait Implementations

`impl<'a> AstBuilder for ExtCtxt<'a>`

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

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

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

`fn path_all(&self, sp: Span, global: bool, idents: Vec<Ident>, lifetimes: Vec<Lifetime>, types: Vec<P<Ty>>, bindings: Vec<P<TypeBinding>>) -> Path`

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

`fn qpath_all(&self, self_type: P<Ty>, trait_path: Path, ident: Ident, lifetimes: Vec<Lifetime>, types: Vec<P<Ty>>, bindings: Vec<P<TypeBinding>>) -> (QSelf, Path)`

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

`fn ty(&self, span: Span, ty: Ty_) -> P<Ty>`

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

`fn ty_sum(&self, path: Path, bounds: OwnedSlice<TyParamBound>) -> P<Ty>`

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

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

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

`fn ty_option(&self, ty: P<Ty>) -> P<Ty>`

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

`fn typaram(&self, span: Span, id: Ident, bounds: OwnedSlice<TyParamBound>, default: Option<P<Ty>>) -> TyParam`

`fn ty_vars(&self, ty_params: &OwnedSlice<TyParam>) -> Vec<P<Ty>>`

`fn ty_vars_global(&self, ty_params: &OwnedSlice<TyParam>) -> Vec<P<Ty>>`

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

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

`fn typarambound(&self, path: Path) -> TyParamBound`

`fn lifetime(&self, span: Span, name: Name) -> Lifetime`

`fn lifetime_def(&self, span: Span, name: Name, bounds: Vec<Lifetime>) -> LifetimeDef`

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

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

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

`fn block(&self, span: Span, stmts: Vec<P<Stmt>>, expr: Option<P<Expr>>) -> P<Block>`

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

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

`fn block_all(&self, span: Span, stmts: Vec<P<Stmt>>, expr: Option<P<Expr>>) -> P<Block>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn expr_lit(&self, sp: Span, lit: Lit_) -> P<Expr>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn pat(&self, span: Span, pat: Pat_) -> P<Pat>`

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

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

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

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

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

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

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

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

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

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

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

`fn arm(&self, _span: Span, pats: Vec<P<Pat>>, expr: P<Expr>) -> Arm`

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

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

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

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

`fn lambda_fn_decl(&self, span: Span, fn_decl: P<FnDecl>, blk: P<Block>) -> P<Expr>`

`fn lambda(&self, span: Span, ids: Vec<Ident>, blk: P<Block>) -> P<Expr>`

`fn lambda0(&self, span: Span, blk: P<Block>) -> P<Expr>`

`fn lambda1(&self, span: Span, blk: P<Block>, ident: Ident) -> P<Expr>`

`fn lambda_expr(&self, span: Span, ids: Vec<Ident>, expr: P<Expr>) -> P<Expr>`

`fn lambda_expr_0(&self, span: Span, expr: P<Expr>) -> P<Expr>`

`fn lambda_expr_1(&self, span: Span, expr: P<Expr>, ident: Ident) -> P<Expr>`

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

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

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

`fn arg(&self, span: Span, ident: Ident, ty: P<Ty>) -> Arg`

`fn fn_decl(&self, inputs: Vec<Arg>, output: P<Ty>) -> P<FnDecl>`

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

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

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

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

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

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

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

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

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

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

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

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

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

`fn attribute(&self, sp: Span, mi: P<MetaItem>) -> Attribute`

`fn meta_word(&self, sp: Span, w: InternedString) -> P<MetaItem>`

`fn meta_list(&self, sp: Span, name: InternedString, mis: Vec<P<MetaItem>>) -> P<MetaItem>`

`fn meta_name_value(&self, sp: Span, name: InternedString, value: Lit_) -> P<MetaItem>`

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

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

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

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

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

`impl<'a> ExtParseUtils for ExtCtxt<'a>`

`fn parse_item(&self, s: String) -> P<Item>`

`fn parse_stmt(&self, s: String) -> P<Stmt>`

`fn parse_expr(&self, s: String) -> P<Expr>`

`fn parse_tts(&self, s: String) -> Vec<TokenTree>`