[−][src]Struct syntax::ext::base::ExtCtxt
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 dyn Resolver
current_expansion: ExpansionData
expansions: FxHashMap<Span, Vec<String>>
Methods
impl<'a> ExtCtxt<'a>
[src]
pub fn new(
parse_sess: &'a ParseSess,
ecfg: ExpansionConfig<'a>,
resolver: &'a mut dyn Resolver
) -> ExtCtxt<'a>
[src]
parse_sess: &'a ParseSess,
ecfg: ExpansionConfig<'a>,
resolver: &'a mut dyn Resolver
) -> ExtCtxt<'a>
pub fn expander<'b>(&'b mut self) -> MacroExpander<'b, 'a>
[src]
Returns a Folder
for deeply expanding all macros in an AST node.
pub fn monotonic_expander<'b>(&'b mut self) -> MacroExpander<'b, 'a>
[src]
Returns a Folder
that deeply expands all macros and assigns all NodeId
s in an AST node.
Once NodeId
s 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 source_map(&self) -> &'a SourceMap
[src]
pub fn parse_sess(&self) -> &'a ParseSess
[src]
pub fn cfg(&self) -> &CrateConfig
[src]
pub fn call_site(&self) -> Span
[src]
pub fn backtrace(&self) -> SyntaxContext
[src]
pub fn expansion_cause(&self) -> Option<Span>
[src]
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]
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
pub fn struct_span_err<S: Into<MultiSpan>>(
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
[src]
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
pub fn struct_span_fatal<S: Into<MultiSpan>>(
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
[src]
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
pub fn span_fatal<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
[src]
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]
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]
&self,
sp: S,
msg: &str,
code: DiagnosticId
)
pub fn mut_span_err<S: Into<MultiSpan>>(
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
[src]
&self,
sp: S,
msg: &str
) -> DiagnosticBuilder<'a>
pub fn span_warn<S: Into<MultiSpan>>(&self, sp: S, msg: &str)
[src]
pub fn span_unimpl<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
[src]
pub fn span_bug<S: Into<MultiSpan>>(&self, sp: S, msg: &str) -> !
[src]
pub fn trace_macros_diag(&mut self)
[src]
pub fn bug(&self, msg: &str) -> !
[src]
pub fn trace_macros(&self) -> bool
[src]
pub fn set_trace_macros(&mut self, x: bool)
[src]
pub fn ident_of(&self, st: &str) -> Ident
[src]
pub fn std_path(&self, components: &[&str]) -> Vec<Ident>
[src]
pub fn name_of(&self, st: &str) -> Name
[src]
pub fn check_unused_macros(&self)
[src]
Trait Implementations
impl<'a> AstBuilder for ExtCtxt<'a>
[src]
fn path(&self, span: Span, strs: Vec<Ident>) -> Path
[src]
fn path_ident(&self, span: Span, id: Ident) -> Path
[src]
fn path_global(&self, span: Span, strs: Vec<Ident>) -> Path
[src]
fn path_all(
&self,
span: Span,
global: bool,
idents: Vec<Ident>,
args: Vec<GenericArg>,
bindings: Vec<TypeBinding>
) -> Path
[src]
&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]
&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]
&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(&self, span: Span, ty: TyKind) -> P<Ty>
[src]
fn ty_path(&self, path: Path) -> P<Ty>
[src]
fn ty_ident(&self, span: Span, ident: Ident) -> P<Ty>
[src]
fn anon_const(&self, span: Span, expr: ExprKind) -> AnonConst
[src]
fn const_ident(&self, span: Span, ident: Ident) -> AnonConst
[src]
fn ty_rptr(
&self,
span: Span,
ty: P<Ty>,
lifetime: Option<Lifetime>,
mutbl: Mutability
) -> P<Ty>
[src]
&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_option(&self, ty: P<Ty>) -> P<Ty>
[src]
fn ty_infer(&self, span: Span) -> P<Ty>
[src]
fn typaram(
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds,
default: Option<P<Ty>>
) -> GenericParam
[src]
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds,
default: Option<P<Ty>>
) -> GenericParam
fn trait_ref(&self, path: Path) -> TraitRef
[src]
fn poly_trait_ref(&self, span: Span, path: Path) -> PolyTraitRef
[src]
fn trait_bound(&self, path: Path) -> GenericBound
[src]
fn lifetime(&self, span: Span, ident: Ident) -> Lifetime
[src]
fn lifetime_def(
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds
) -> GenericParam
[src]
&self,
span: Span,
ident: Ident,
attrs: Vec<Attribute>,
bounds: GenericBounds
) -> GenericParam
fn stmt_expr(&self, expr: P<Expr>) -> Stmt
[src]
fn stmt_semi(&self, expr: P<Expr>) -> Stmt
[src]
fn stmt_let(&self, sp: Span, mutbl: bool, ident: Ident, ex: P<Expr>) -> Stmt
[src]
fn stmt_let_typed(
&self,
sp: Span,
mutbl: bool,
ident: Ident,
typ: P<Ty>,
ex: P<Expr>
) -> Stmt
[src]
&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_item(&self, sp: Span, item: P<Item>) -> Stmt
[src]
fn block_expr(&self, expr: P<Expr>) -> P<Block>
[src]
fn block(&self, span: Span, stmts: Vec<Stmt>) -> P<Block>
[src]
fn expr(&self, span: Span, node: ExprKind) -> P<Expr>
[src]
fn expr_path(&self, path: Path) -> P<Expr>
[src]
fn expr_qpath(&self, span: Span, qself: QSelf, path: Path) -> P<Expr>
[src]
Constructs a QPath expression.
fn expr_ident(&self, span: Span, id: Ident) -> P<Expr>
[src]
fn expr_self(&self, span: Span) -> P<Expr>
[src]
fn expr_binary(
&self,
sp: Span,
op: BinOpKind,
lhs: P<Expr>,
rhs: P<Expr>
) -> P<Expr>
[src]
&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_unary(&self, sp: Span, op: UnOp, e: P<Expr>) -> P<Expr>
[src]
fn expr_field_access(&self, sp: Span, expr: P<Expr>, ident: Ident) -> P<Expr>
[src]
fn expr_tup_field_access(&self, sp: Span, expr: P<Expr>, idx: usize) -> P<Expr>
[src]
fn expr_addr_of(&self, sp: Span, e: P<Expr>) -> P<Expr>
[src]
fn expr_mut_addr_of(&self, sp: Span, e: P<Expr>) -> P<Expr>
[src]
fn expr_call(&self, span: Span, expr: P<Expr>, args: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_call_ident(&self, span: Span, id: 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>
[src]
&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]
&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 field_imm(&self, span: Span, ident: Ident, e: P<Expr>) -> Field
[src]
fn expr_struct(&self, span: Span, path: Path, fields: Vec<Field>) -> P<Expr>
[src]
fn expr_struct_ident(
&self,
span: Span,
id: Ident,
fields: Vec<Field>
) -> P<Expr>
[src]
&self,
span: Span,
id: Ident,
fields: Vec<Field>
) -> P<Expr>
fn expr_lit(&self, sp: Span, lit: LitKind) -> P<Expr>
[src]
fn expr_usize(&self, span: Span, i: usize) -> P<Expr>
[src]
fn expr_isize(&self, sp: Span, i: isize) -> P<Expr>
[src]
fn expr_u32(&self, sp: Span, u: u32) -> P<Expr>
[src]
fn expr_u16(&self, sp: Span, u: u16) -> P<Expr>
[src]
fn expr_u8(&self, sp: Span, u: u8) -> P<Expr>
[src]
fn expr_bool(&self, sp: Span, value: bool) -> P<Expr>
[src]
fn expr_vec(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_vec_ng(&self, sp: Span) -> P<Expr>
[src]
fn expr_vec_slice(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_str(&self, sp: Span, s: Symbol) -> P<Expr>
[src]
fn expr_cast(&self, sp: Span, expr: P<Expr>, ty: P<Ty>) -> P<Expr>
[src]
fn expr_some(&self, sp: Span, expr: P<Expr>) -> P<Expr>
[src]
fn expr_none(&self, sp: Span) -> P<Expr>
[src]
fn expr_break(&self, sp: Span) -> P<Expr>
[src]
fn expr_tuple(&self, sp: Span, exprs: Vec<P<Expr>>) -> P<Expr>
[src]
fn expr_fail(&self, span: Span, msg: Symbol) -> P<Expr>
[src]
fn expr_unreachable(&self, span: Span) -> P<Expr>
[src]
fn expr_ok(&self, sp: Span, expr: P<Expr>) -> P<Expr>
[src]
fn expr_err(&self, sp: Span, expr: P<Expr>) -> P<Expr>
[src]
fn expr_try(&self, sp: Span, head: P<Expr>) -> P<Expr>
[src]
fn pat(&self, span: Span, pat: PatKind) -> P<Pat>
[src]
fn pat_wild(&self, span: Span) -> P<Pat>
[src]
fn pat_lit(&self, span: Span, expr: P<Expr>) -> P<Pat>
[src]
fn pat_ident(&self, span: Span, ident: Ident) -> P<Pat>
[src]
fn pat_ident_binding_mode(
&self,
span: Span,
ident: Ident,
bm: BindingMode
) -> P<Pat>
[src]
&self,
span: Span,
ident: Ident,
bm: BindingMode
) -> P<Pat>
fn pat_path(&self, span: Span, path: Path) -> P<Pat>
[src]
fn pat_tuple_struct(
&self,
span: Span,
path: Path,
subpats: Vec<P<Pat>>
) -> P<Pat>
[src]
&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]
&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_some(&self, span: Span, pat: P<Pat>) -> P<Pat>
[src]
fn pat_none(&self, span: Span) -> P<Pat>
[src]
fn pat_ok(&self, span: Span, pat: P<Pat>) -> P<Pat>
[src]
fn pat_err(&self, span: Span, pat: P<Pat>) -> P<Pat>
[src]
fn arm(&self, _span: Span, pats: Vec<P<Pat>>, expr: P<Expr>) -> Arm
[src]
fn arm_unreachable(&self, span: Span) -> Arm
[src]
fn expr_match(&self, span: Span, arg: P<Expr>, arms: Vec<Arm>) -> P<Expr>
[src]
fn expr_if(
&self,
span: Span,
cond: P<Expr>,
then: P<Expr>,
els: Option<P<Expr>>
) -> P<Expr>
[src]
&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 lambda_fn_decl(
&self,
span: Span,
fn_decl: P<FnDecl>,
body: P<Expr>,
fn_decl_span: Span
) -> P<Expr>
[src]
&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 lambda0(&self, span: Span, body: P<Expr>) -> P<Expr>
[src]
fn lambda1(&self, span: Span, body: P<Expr>, ident: Ident) -> P<Expr>
[src]
fn lambda_stmts(&self, span: Span, ids: Vec<Ident>, stmts: Vec<Stmt>) -> P<Expr>
[src]
fn lambda_stmts_0(&self, span: Span, stmts: Vec<Stmt>) -> P<Expr>
[src]
fn lambda_stmts_1(&self, span: Span, stmts: Vec<Stmt>, ident: Ident) -> P<Expr>
[src]
fn arg(&self, span: Span, ident: Ident, ty: P<Ty>) -> Arg
[src]
fn fn_decl(&self, inputs: Vec<Arg>, output: FunctionRetTy) -> P<FnDecl>
[src]
fn item(
&self,
span: Span,
name: Ident,
attrs: Vec<Attribute>,
node: ItemKind
) -> P<Item>
[src]
&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]
&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]
&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 item_enum_poly(
&self,
span: Span,
name: Ident,
enum_definition: EnumDef,
generics: Generics
) -> P<Item>
[src]
&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]
&self,
span: Span,
name: Ident,
enum_definition: EnumDef
) -> P<Item>
fn item_struct(
&self,
span: Span,
name: Ident,
struct_def: VariantData
) -> P<Item>
[src]
&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]
&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]
&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_static(
&self,
span: Span,
name: Ident,
ty: P<Ty>,
mutbl: Mutability,
expr: P<Expr>
) -> P<Item>
[src]
&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]
&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]
&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 attribute(&self, sp: Span, mi: MetaItem) -> Attribute
[src]
fn meta_word(&self, sp: Span, w: Name) -> MetaItem
[src]
fn meta_list_item_word(&self, sp: Span, w: Name) -> NestedMetaItem
[src]
fn meta_list(&self, sp: Span, name: Name, mis: Vec<NestedMetaItem>) -> MetaItem
[src]
fn meta_name_value(&self, sp: Span, name: Name, value: LitKind) -> MetaItem
[src]
fn item_use(&self, sp: Span, vis: Visibility, vp: P<UseTree>) -> P<Item>
[src]
fn item_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> P<Item>
[src]
fn item_use_simple_(
&self,
sp: Span,
vis: Visibility,
rename: Option<Ident>,
path: Path
) -> P<Item>
[src]
&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]
&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]
Auto Trait Implementations
Blanket Implementations
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T> From for T
[src]
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<E> SpecializationError for E
[src]
impl<T> Send for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> Sync for T where
T: ?Sized,
[src]
T: ?Sized,