syntax​::ext​::base

Structs

BasicIdentMacroExpanderBasicMacroExpanderBlockInfoDummyResultExtCtxtMacExprMacItemMacPatMacroDefSyntaxEnv

Traits

IdentMacroExpanderMacResultMacroExpander

Functions

check_zero_ttsexpr_to_strget_exprs_from_ttsget_single_str_from_ttssyntax_expander_table

Struct syntax::ext::base::ExtCtxt[src]

pub struct ExtCtxt<'a> {
    pub parse_sess: &'a ParseSess,
    pub cfg: CrateConfig,
    pub backtrace: Option<Gc<ExpnInfo>>,
    pub ecfg: ExpansionConfig,
    pub mod_path: Vec<Ident>,
    pub trace_mac: bool,
}

Fields

parse_sess
cfg
backtrace
ecfg
mod_path
trace_mac

Methods

impl<'a> ExtCtxt<'a>

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

fn expand_expr(&mut self, e: Gc<Expr>) -> Gc<Expr>

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

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

fn cfg(&self) -> CrateConfig

fn call_site(&self) -> Span

fn print_backtrace(&self)

fn backtrace(&self) -> Option<Gc<ExpnInfo>>

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 span_fatal(&self, sp: Span, msg: &str) -> !

Emit msg attached to sp, and stop compilation immediately.

span_err should be strongly prefered 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 bug(&self, msg: &str) -> !

fn trace_macros(&self) -> bool

fn set_trace_macros(&mut self, x: bool)

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

Trait Implementations

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

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

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

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

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

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>>) -> 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, bounds: Option<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_uniq(&self, span: Span, ty: P<Ty>) -> P<Ty>

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

fn ty_field_imm(&self, span: Span, name: Ident, ty: P<Ty>) -> TypeField

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

fn ty_nil(&self) -> P<Ty>

fn typaram(&self, span: Span, id: Ident, sized: Sized, 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 strip_bounds(&self, generics: &Generics) -> Generics

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn expr_binary(&self, sp: Span, op: BinOp, lhs: Gc<Expr>, rhs: Gc<Expr>) -> Gc<Expr>

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

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

fn expr_managed(&self, sp: Span, e: Gc<Expr>) -> Gc<Expr>

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

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

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

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

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

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

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

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

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

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

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

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

fn expr_uint(&self, span: Span, i: uint) -> Gc<Expr>

fn expr_int(&self, sp: Span, i: int) -> Gc<Expr>

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

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

fn expr_vstore(&self, sp: Span, expr: Gc<Expr>, vst: ExprVstore) -> Gc<Expr>

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

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

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

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

fn expr_str_uniq(&self, sp: Span, s: InternedString) -> Gc<Expr>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn lambda_stmts_1(&self, span: Span, stmts: Vec<Gc<Stmt>>, ident: Ident) -> Gc<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_) -> Gc<Item>

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

fn item_fn(&self, span: Span, name: Ident, inputs: Vec<Arg>, output: P<Ty>, body: P<Block>) -> Gc<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) -> Gc<Item>

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

fn item_struct(&self, span: Span, name: Ident, struct_def: StructDef) -> Gc<Item>

fn item_struct_poly(&self, span: Span, name: Ident, struct_def: StructDef, generics: Generics) -> Gc<Item>

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

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

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

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

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

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

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

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

fn view_use(&self, sp: Span, vis: Visibility, vp: Gc<ViewPath>) -> ViewItem

fn view_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> ViewItem

fn view_use_simple_(&self, sp: Span, vis: Visibility, ident: Ident, path: Path) -> ViewItem

fn view_use_list(&self, sp: Span, vis: Visibility, path: Vec<Ident>, imports: &[Ident]) -> ViewItem

fn view_use_glob(&self, sp: Span, vis: Visibility, path: Vec<Ident>) -> ViewItem