Trait syntax::ext::build::AstBuilderUnstable

pub trait AstBuilder {
    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_ref: P<TraitRef>, ident: Ident) -> P<QPath>;
    fn qpath_all(&self, self_type: P<Ty>, trait_ref: P<TraitRef>, ident: Ident, lifetimes: Vec<Lifetime>, types: Vec<P<Ty>>, bindings: Vec<P<TypeBinding>>) -> P<QPath>;
    fn ty_mt(&self, ty: P<Ty>, mutbl: Mutability) -> MutTy;
    fn ty(&self, span: Span, ty: Ty_) -> P<Ty>;
    fn ty_path(&self, Path) -> P<Ty>;
    fn ty_sum(&self, Path, OwnedSlice<TyParamBound>) -> P<Ty>;
    fn ty_ident(&self, span: Span, idents: 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, sp: Span) -> P<Ty>;
    fn ty_vars(&self, ty_params: &OwnedSlice<TyParam>) -> Vec<P<Ty>>;
    fn ty_vars_global(&self, ty_params: &OwnedSlice<TyParam>) -> Vec<P<Ty>>;
    fn ty_field_imm(&self, span: Span, name: Ident, ty: P<Ty>) -> TypeField;
    fn typaram(&self, span: Span, id: Ident, bounds: OwnedSlice<TyParamBound>, default: Option<P<Ty>>) -> TyParam;
    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, ident: 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 stmt_item(&self, sp: Span, item: P<Item>) -> P<Stmt>;
    fn block(&self, span: Span, stmts: Vec<P<Stmt>>, expr: Option<P<Expr>>) -> P<Block>;
    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, qpath: P<QPath>) -> P<Expr>;
    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_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_field_access(&self, span: 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_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 expr_cast(&self, sp: Span, expr: P<Expr>, ty: P<Ty>) -> 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_int(&self, sp: Span, i: isize) -> 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_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, span: Span, expr: P<Expr>) -> P<Expr>;
    fn expr_err(&self, span: Span, expr: P<Expr>) -> P<Expr>;
    fn expr_try(&self, span: 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>, blk: 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>, blk: 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 item(&self, span: Span, name: Ident, attrs: Vec<Attribute>, node: Item_) -> P<Item>;
    fn arg(&self, span: Span, name: Ident, ty: P<Ty>) -> Arg;
    fn fn_decl(&self, inputs: Vec<Arg>, output: P<Ty>) -> P<FnDecl>;
    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_def: EnumDef) -> P<Item>;
    fn item_struct_poly(&self, span: Span, name: Ident, struct_def: StructDef, generics: Generics) -> P<Item>;
    fn item_struct(&self, span: Span, name: Ident, struct_def: StructDef) -> 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>;
}

Required Methods

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_ref: P<TraitRef>, ident: Ident) -> P<QPath>

fn qpath_all(&self, self_type: P<Ty>, trait_ref: P<TraitRef>, ident: Ident, lifetimes: Vec<Lifetime>, types: Vec<P<Ty>>, bindings: Vec<P<TypeBinding>>) -> P<QPath>

fn ty_mt(&self, ty: P<Ty>, mutbl: Mutability) -> MutTy

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

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

fn ty_sum(&self, Path, OwnedSlice<TyParamBound>) -> P<Ty>

fn ty_ident(&self, span: Span, idents: 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, sp: Span) -> P<Ty>

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

fn ty_vars_global(&self, ty_params: &OwnedSlice<TyParam>) -> Vec<P<Ty>>

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

fn typaram(&self, span: Span, id: Ident, bounds: OwnedSlice<TyParamBound>, default: Option<P<Ty>>) -> TyParam

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, ident: 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 stmt_item(&self, sp: Span, item: P<Item>) -> P<Stmt>

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

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, qpath: P<QPath>) -> P<Expr>

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_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_field_access(&self, span: 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_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 expr_cast(&self, sp: Span, expr: P<Expr>, ty: P<Ty>) -> 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_int(&self, sp: Span, i: isize) -> 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_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, span: Span, expr: P<Expr>) -> P<Expr>

fn expr_err(&self, span: Span, expr: P<Expr>) -> P<Expr>

fn expr_try(&self, span: 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>, blk: 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>, blk: 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 item(&self, span: Span, name: Ident, attrs: Vec<Attribute>, node: Item_) -> P<Item>

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

fn fn_decl(&self, inputs: Vec<Arg>, output: P<Ty>) -> P<FnDecl>

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_def: EnumDef) -> P<Item>

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

fn item_struct(&self, span: Span, name: Ident, struct_def: StructDef) -> 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>

Implementors

• impl<'a> AstBuilder for ExtCtxt<'a>