Struct syntex_syntax::ext::base::ExtCtxt

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)

Constructs a qualified path.

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

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)

Constructs a qualified path.

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

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>

Constructs a QPath expression.

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>