Struct syntax::ext::base::ExtCtxt [−][src]
pub struct ExtCtxt<'a> { pub parse_sess: &'a ParseSess, pub ecfg: ExpansionConfig<'a>, pub root_path: PathBuf, pub resolver: &'a mut Resolver, pub resolve_err_count: usize, pub current_expansion: ExpansionData, pub expansions: HashMap<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_info
of their expansion context stored into their span.
Fields
parse_sess: &'a ParseSess
ecfg: ExpansionConfig<'a>
root_path: PathBuf
resolver: &'a mut Resolver
resolve_err_count: usize
current_expansion: ExpansionData
expansions: HashMap<Span, Vec<String>>
Methods
impl<'a> ExtCtxt<'a>
[src]
impl<'a> ExtCtxt<'a>
pub fn new(
parse_sess: &'a ParseSess,
ecfg: ExpansionConfig<'a>,
resolver: &'a mut Resolver
) -> ExtCtxt<'a>
[src]
pub fn new(
parse_sess: &'a ParseSess,
ecfg: ExpansionConfig<'a>,
resolver: &'a mut Resolver
) -> ExtCtxt<'a>
pub fn expander<'b>(&'b mut self) -> MacroExpander<'b, 'a>
[src]
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>
[src]
pub 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.
pub fn new_parser_from_tts(&self, tts: &[TokenTree]) -> Parser<'a>
[src]
pub fn new_parser_from_tts(&self, tts: &[TokenTree]) -> Parser<'a>
pub fn codemap(&self) -> &'a CodeMap
[src]
pub fn codemap(&self) -> &'a CodeMap
pub fn parse_sess(&self) -> &'a ParseSess
[src]
pub fn parse_sess(&self) -> &'a ParseSess
pub fn cfg(&self) -> &CrateConfig
[src]
pub fn cfg(&self) -> &CrateConfig
pub fn call_site(&self) -> Span
[src]
pub fn call_site(&self) -> Span
pub fn backtrace(&self) -> SyntaxContext
[src]
pub fn backtrace(&self) -> SyntaxContext
pub fn expansion_cause(&self) -> Option<Span>
[src]
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>
[src]
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>
[src]
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>
[src]
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) -> !
[src]
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)
[src]
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
)
[src]
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>
[src]
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)
[src]
pub fn span_warn<S: Into<MultiSpan>>(&self, sp: S, msg: &str)
pub fn span_unimpl<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
[src]
pub fn span_unimpl<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
[src]
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
pub fn trace_macros_diag(&mut self)
[src]
pub fn trace_macros_diag(&mut self)
pub fn bug(&self, msg: &str) -> !
[src]
pub fn bug(&self, msg: &str) -> !
pub fn trace_macros(&self) -> bool
[src]
pub fn trace_macros(&self) -> bool
pub fn set_trace_macros(&mut self, x: bool)
[src]
pub fn set_trace_macros(&mut self, x: bool)
pub fn ident_of(&self, st: &str) -> Ident
[src]
pub fn ident_of(&self, st: &str) -> Ident
pub fn std_path(&self, components: &[&str]) -> Vec<Ident>
[src]
pub fn std_path(&self, components: &[&str]) -> Vec<Ident>
pub fn name_of(&self, st: &str) -> Name
[src]
pub fn name_of(&self, st: &str) -> Name
pub fn check_unused_macros(&self)
[src]
pub fn check_unused_macros(&self)
Trait Implementations
impl<'a> AstBuilder for ExtCtxt<'a>
[src]
impl<'a> AstBuilder for ExtCtxt<'a>
fn path(&self, span: Span, strs: Vec<Ident>) -> Path
[src]
fn path(&self, span: Span, strs: Vec<Ident>) -> Path
fn path_ident(&self, span: Span, id: Ident) -> Path
[src]
fn path_ident(&self, span: Span, id: Ident) -> Path
fn path_global(&self, span: Span, strs: Vec<Ident>) -> Path
[src]
fn path_global(&self, span: Span, strs: Vec<Ident>) -> Path
fn path_all(
&self,
span: Span,
global: bool,
idents: Vec<Ident>,
args: Vec<GenericArg>,
bindings: Vec<TypeBinding>
) -> Path
[src]
fn path_all(
&self,
span: Span,
global: bool,
idents: Vec<Ident>,
args: Vec<GenericArg>,
bindings: Vec<TypeBinding>
) -> Path
fn qpath(
&self,
self_type: P<Ty>,
trait_path: Path,
ident: Ident
) -> (QSelf, Path)
[src]
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,
args: Vec<GenericArg>,
bindings: Vec<TypeBinding>
) -> (QSelf, Path)
[src]
fn qpath_all(
&self,
self_type: P<Ty>,
trait_path: Path,
ident: Ident,
args: Vec<GenericArg>,
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
[src]
fn ty_mt(&self, ty: P<Ty>, mutbl: Mutability) -> MutTy
fn ty(&self, span: Span, ty: TyKind) -> P<Ty>
[src]
fn ty(&self, span: Span, ty: TyKind) -> P<Ty>
fn ty_path(&self, path: Path) -> P<Ty>
[src]
fn ty_path(&self, path: Path) -> P<Ty>
fn ty_ident(&self, span: Span, ident: Ident) -> P<Ty>
[src]
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>
[src]
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>
[src]
fn ty_ptr(&self, span: Span, ty: P<Ty>, mutbl: Mutability) -> P<Ty>
fn ty_option(&self, ty: P<Ty>) -> P<Ty>
[src]
fn ty_option(&self, ty: P<Ty>) -> P<Ty>
fn ty_infer(&self, span: Span) -> P<Ty>
[src]
fn ty_infer(&self, span: Span) -> P<Ty>
fn typaram(
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds,
default: Option<P<Ty>>
) -> GenericParam
[src]
fn typaram(
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds,
default: Option<P<Ty>>
) -> GenericParam
fn trait_ref(&self, path: Path) -> TraitRef
[src]
fn trait_ref(&self, path: Path) -> TraitRef
fn poly_trait_ref(&self, span: Span, path: Path) -> PolyTraitRef
[src]
fn poly_trait_ref(&self, span: Span, path: Path) -> PolyTraitRef
fn trait_bound(&self, path: Path) -> GenericBound
[src]
fn trait_bound(&self, path: Path) -> GenericBound
fn lifetime(&self, span: Span, ident: Ident) -> Lifetime
[src]
fn lifetime(&self, span: Span, ident: Ident) -> Lifetime
fn lifetime_def(
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds
) -> GenericParam
[src]
fn lifetime_def(
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds
) -> GenericParam
fn stmt_expr(&self, expr: P<Expr>) -> Stmt
[src]
fn stmt_expr(&self, expr: P<Expr>) -> Stmt
fn stmt_semi(&self, expr: P<Expr>) -> Stmt
[src]
fn stmt_semi(&self, expr: P<Expr>) -> Stmt
fn stmt_let(&self, sp: Span, mutbl: bool, ident: Ident, ex: P<Expr>) -> Stmt
[src]
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
[src]
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
[src]
fn stmt_let_type_only(&self, span: Span, ty: P<Ty>) -> Stmt
fn stmt_item(&self, sp: Span, item: P<Item>) -> Stmt
[src]
fn stmt_item(&self, sp: Span, item: P<Item>) -> Stmt
fn block_expr(&self, expr: P<Expr>) -> P<Block>
[src]
fn block_expr(&self, expr: P<Expr>) -> P<Block>
fn block(&self, span: Span, stmts: Vec<Stmt>) -> P<Block>
[src]
fn block(&self, span: Span, stmts: Vec<Stmt>) -> P<Block>
fn expr(&self, span: Span, node: ExprKind) -> P<Expr>
[src]
fn expr(&self, span: Span, node: ExprKind) -> P<Expr>
fn expr_path(&self, path: Path) -> P<Expr>
[src]
fn expr_path(&self, path: Path) -> P<Expr>
fn expr_qpath(&self, span: Span, qself: QSelf, path: Path) -> P<Expr>
[src]
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>
[src]
fn expr_ident(&self, span: Span, id: Ident) -> P<Expr>
fn expr_self(&self, span: Span) -> P<Expr>
[src]
fn expr_self(&self, span: Span) -> P<Expr>
fn expr_binary(
&self,
sp: Span,
op: BinOpKind,
lhs: P<Expr>,
rhs: P<Expr>
) -> P<Expr>
[src]
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>
[src]
fn expr_deref(&self, sp: Span, e: P<Expr>) -> P<Expr>
fn expr_unary(&self, sp: Span, op: UnOp, e: P<Expr>) -> P<Expr>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
fn expr_block(&self, b: P<Block>) -> P<Expr>
fn field_imm(&self, span: Span, ident: Ident, e: P<Expr>) -> Field
[src]
fn field_imm(&self, span: Span, ident: Ident, e: P<Expr>) -> Field
fn expr_struct(&self, span: Span, path: Path, fields: Vec<Field>) -> P<Expr>
[src]
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>
[src]
fn expr_struct_ident(
&self,
span: Span,
id: Ident,
fields: Vec<Field>
) -> P<Expr>
fn expr_lit(&self, sp: Span, lit: LitKind) -> P<Expr>
[src]
fn expr_lit(&self, sp: Span, lit: LitKind) -> P<Expr>
fn expr_usize(&self, span: Span, i: usize) -> P<Expr>
[src]
fn expr_usize(&self, span: Span, i: usize) -> P<Expr>
fn expr_isize(&self, sp: Span, i: isize) -> P<Expr>
[src]
fn expr_isize(&self, sp: Span, i: isize) -> P<Expr>
fn expr_u32(&self, sp: Span, u: u32) -> P<Expr>
[src]
fn expr_u32(&self, sp: Span, u: u32) -> P<Expr>
fn expr_u16(&self, sp: Span, u: u16) -> P<Expr>
[src]
fn expr_u16(&self, sp: Span, u: u16) -> P<Expr>
fn expr_u8(&self, sp: Span, u: u8) -> P<Expr>
[src]
fn expr_u8(&self, sp: Span, u: u8) -> P<Expr>
fn expr_bool(&self, sp: Span, value: bool) -> P<Expr>
[src]
fn expr_bool(&self, sp: Span, value: bool) -> P<Expr>
fn expr_vec(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_vec(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
fn expr_vec_ng(&self, sp: Span) -> P<Expr>
[src]
fn expr_vec_ng(&self, sp: Span) -> P<Expr>
fn expr_vec_slice(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_vec_slice(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
fn expr_str(&self, sp: Span, s: Symbol) -> P<Expr>
[src]
fn expr_str(&self, sp: Span, s: Symbol) -> P<Expr>
fn expr_cast(&self, sp: Span, expr: P<Expr>, ty: P<Ty>) -> P<Expr>
[src]
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>
[src]
fn expr_some(&self, sp: Span, expr: P<Expr>) -> P<Expr>
fn expr_none(&self, sp: Span) -> P<Expr>
[src]
fn expr_none(&self, sp: Span) -> P<Expr>
fn expr_break(&self, sp: Span) -> P<Expr>
[src]
fn expr_break(&self, sp: Span) -> P<Expr>
fn expr_tuple(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_tuple(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
fn expr_fail(&self, span: Span, msg: Symbol) -> P<Expr>
[src]
fn expr_fail(&self, span: Span, msg: Symbol) -> P<Expr>
fn expr_unreachable(&self, span: Span) -> P<Expr>
[src]
fn expr_unreachable(&self, span: Span) -> P<Expr>
fn expr_ok(&self, sp: Span, expr: P<Expr>) -> P<Expr>
[src]
fn expr_ok(&self, sp: Span, expr: P<Expr>) -> P<Expr>
fn expr_err(&self, sp: Span, expr: P<Expr>) -> P<Expr>
[src]
fn expr_err(&self, sp: Span, expr: P<Expr>) -> P<Expr>
fn expr_try(&self, sp: Span, head: P<Expr>) -> P<Expr>
[src]
fn expr_try(&self, sp: Span, head: P<Expr>) -> P<Expr>
fn pat(&self, span: Span, pat: PatKind) -> P<Pat>
[src]
fn pat(&self, span: Span, pat: PatKind) -> P<Pat>
fn pat_wild(&self, span: Span) -> P<Pat>
[src]
fn pat_wild(&self, span: Span) -> P<Pat>
fn pat_lit(&self, span: Span, expr: P<Expr>) -> P<Pat>
[src]
fn pat_lit(&self, span: Span, expr: P<Expr>) -> P<Pat>
fn pat_ident(&self, span: Span, ident: Ident) -> P<Pat>
[src]
fn pat_ident(&self, span: Span, ident: Ident) -> P<Pat>
fn pat_ident_binding_mode(
&self,
span: Span,
ident: Ident,
bm: BindingMode
) -> P<Pat>
[src]
fn pat_ident_binding_mode(
&self,
span: Span,
ident: Ident,
bm: BindingMode
) -> P<Pat>
fn pat_path(&self, span: Span, path: Path) -> P<Pat>
[src]
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>
[src]
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>
[src]
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>
[src]
fn pat_tuple(&self, span: Span, pats: Vec<P<Pat>>) -> P<Pat>
fn pat_some(&self, span: Span, pat: P<Pat>) -> P<Pat>
[src]
fn pat_some(&self, span: Span, pat: P<Pat>) -> P<Pat>
fn pat_none(&self, span: Span) -> P<Pat>
[src]
fn pat_none(&self, span: Span) -> P<Pat>
fn pat_ok(&self, span: Span, pat: P<Pat>) -> P<Pat>
[src]
fn pat_ok(&self, span: Span, pat: P<Pat>) -> P<Pat>
fn pat_err(&self, span: Span, pat: P<Pat>) -> P<Pat>
[src]
fn pat_err(&self, span: Span, pat: P<Pat>) -> P<Pat>
fn arm(&self, _span: Span, pats: Vec<P<Pat>>, expr: P<Expr>) -> Arm
[src]
fn arm(&self, _span: Span, pats: Vec<P<Pat>>, expr: P<Expr>) -> Arm
fn arm_unreachable(&self, span: Span) -> Arm
[src]
fn arm_unreachable(&self, span: Span) -> Arm
fn expr_match(&self, span: Span, arg: P<Expr>, arms: Vec<Arm>) -> P<Expr>
[src]
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>
[src]
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>
[src]
fn expr_loop(&self, span: Span, block: P<Block>) -> P<Expr>
fn lambda_fn_decl(
&self,
span: Span,
fn_decl: P<FnDecl>,
body: P<Expr>,
fn_decl_span: Span
) -> P<Expr>
[src]
fn lambda_fn_decl(
&self,
span: Span,
fn_decl: P<FnDecl>,
body: P<Expr>,
fn_decl_span: Span
) -> P<Expr>
fn lambda(&self, span: Span, ids: Vec<Ident>, body: P<Expr>) -> P<Expr>
[src]
fn lambda(&self, span: Span, ids: Vec<Ident>, body: P<Expr>) -> P<Expr>
fn lambda0(&self, span: Span, body: P<Expr>) -> P<Expr>
[src]
fn lambda0(&self, span: Span, body: P<Expr>) -> P<Expr>
fn lambda1(&self, span: Span, body: P<Expr>, ident: Ident) -> P<Expr>
[src]
fn lambda1(&self, span: Span, body: P<Expr>, ident: Ident) -> P<Expr>
fn lambda_stmts(&self, span: Span, ids: Vec<Ident>, stmts: Vec<Stmt>) -> P<Expr>
[src]
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>
[src]
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>
[src]
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
[src]
fn arg(&self, span: Span, ident: Ident, ty: P<Ty>) -> Arg
fn fn_decl(&self, inputs: Vec<Arg>, output: FunctionRetTy) -> P<FnDecl>
[src]
fn fn_decl(&self, inputs: Vec<Arg>, output: FunctionRetTy) -> P<FnDecl>
fn item(
&self,
span: Span,
name: Ident,
attrs: Vec<Attribute>,
node: ItemKind
) -> P<Item>
[src]
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>
[src]
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>
[src]
fn item_fn(
&self,
span: Span,
name: Ident,
inputs: Vec<Arg>,
output: P<Ty>,
body: P<Block>
) -> P<Item>
fn variant(&self, span: Span, ident: Ident, tys: Vec<P<Ty>>) -> Variant
[src]
fn variant(&self, span: Span, ident: Ident, tys: Vec<P<Ty>>) -> Variant
fn item_enum_poly(
&self,
span: Span,
name: Ident,
enum_definition: EnumDef,
generics: Generics
) -> P<Item>
[src]
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>
[src]
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>
[src]
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>
[src]
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>
[src]
fn item_mod(
&self,
span: Span,
inner_span: Span,
name: Ident,
attrs: Vec<Attribute>,
items: Vec<P<Item>>
) -> P<Item>
fn item_extern_crate(&self, span: Span, name: Ident) -> P<Item>
[src]
fn item_extern_crate(&self, span: Span, name: Ident) -> P<Item>
fn item_static(
&self,
span: Span,
name: Ident,
ty: P<Ty>,
mutbl: Mutability,
expr: P<Expr>
) -> P<Item>
[src]
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>
[src]
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>
[src]
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>
[src]
fn item_ty(&self, span: Span, name: Ident, ty: P<Ty>) -> P<Item>
fn attribute(&self, sp: Span, mi: MetaItem) -> Attribute
[src]
fn attribute(&self, sp: Span, mi: MetaItem) -> Attribute
fn meta_word(&self, sp: Span, w: Name) -> MetaItem
[src]
fn meta_word(&self, sp: Span, w: Name) -> MetaItem
fn meta_list_item_word(&self, sp: Span, w: Name) -> NestedMetaItem
[src]
fn meta_list_item_word(&self, sp: Span, w: Name) -> NestedMetaItem
fn meta_list(&self, sp: Span, name: Name, mis: Vec<NestedMetaItem>) -> MetaItem
[src]
fn meta_list(&self, sp: Span, name: Name, mis: Vec<NestedMetaItem>) -> MetaItem
fn meta_name_value(&self, sp: Span, name: Name, value: LitKind) -> MetaItem
[src]
fn meta_name_value(&self, sp: Span, name: Name, value: LitKind) -> MetaItem
fn item_use(&self, sp: Span, vis: Visibility, vp: P<UseTree>) -> P<Item>
[src]
fn item_use(&self, sp: Span, vis: Visibility, vp: P<UseTree>) -> P<Item>
fn item_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> P<Item>
[src]
fn item_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> P<Item>
fn item_use_simple_(
&self,
sp: Span,
vis: Visibility,
rename: Option<Ident>,
path: Path
) -> P<Item>
[src]
fn item_use_simple_(
&self,
sp: Span,
vis: Visibility,
rename: Option<Ident>,
path: Path
) -> P<Item>
fn item_use_list(
&self,
sp: Span,
vis: Visibility,
path: Vec<Ident>,
imports: &[Ident]
) -> P<Item>
[src]
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>
[src]
fn item_use_glob(&self, sp: Span, vis: Visibility, path: Vec<Ident>) -> P<Item>
impl<'a> ExtParseUtils for ExtCtxt<'a>
[src]
impl<'a> ExtParseUtils for ExtCtxt<'a>