Struct syntex_syntax::ext::base::ExtCtxt

pub struct ExtCtxt<'a> {
    pub parse_sess: &'a ParseSess,
    pub cfg: CrateConfig,
    pub ecfg: ExpansionConfig<'a>,
    pub crate_root: Option<&'static str>,
    pub resolver: &'a mut Resolver,
    pub resolve_err_count: usize,
    pub current_expansion: ExpansionData,
}

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: &'a ParseSess

cfg: CrateConfig

ecfg: ExpansionConfig<'a>

crate_root: Option<&'static str>

resolver: &'a mut Resolver

resolve_err_count: usize

current_expansion: ExpansionData

Methods

impl<'a> ExtCtxt<'a>

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

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

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

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

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

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 expansion_cause(&self) -> Span

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

Stops backtracing at include! boundary.

fn bt_push(&mut self, ei: ExpnInfo)

fn bt_pop(&mut self)

fn struct_span_warn(&self, sp: Span, msg: &str) -> DiagnosticBuilder<'a>

fn struct_span_err(&self, sp: Span, msg: &str) -> DiagnosticBuilder<'a>

fn struct_span_fatal(&self, sp: Span, msg: &str) -> DiagnosticBuilder<'a>

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 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

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<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<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: TyKind) -> P<Ty>

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

fn ty_sum(&self, path: Path, bounds: TyParamBounds) -> 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, attrs: Vec<Attribute>, bounds: TyParamBounds, default: Option<P<Ty>>) -> TyParam

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

fn ty_vars_global(&self, ty_params: &P<[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, attrs: Vec<Attribute>, bounds: Vec<Lifetime>) -> LifetimeDef

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

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

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

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

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

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

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

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

fn expr(&self, span: Span, node: ExprKind) -> 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: BinOpKind, 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: LitKind) -> 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: PatKind) -> 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_path(&self, span: Span, path: Path) -> P<Pat>

fn pat_tuple_struct(&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>, fn_decl_span: Span) -> 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<Stmt>) -> P<Expr>

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

fn lambda_stmts_1(&self, span: Span, stmts: Vec<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: ItemKind) -> 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_item_word(&self, sp: Span, w: InternedString) -> NestedMetaItem

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

fn meta_name_value(&self, sp: Span, name: InternedString, value: LitKind) -> 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) -> Stmt

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

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