[−][src]Trait syntax::ext::build::AstBuilder

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>, 
        args: Vec<GenericArg>, 
        bindings: Vec<TypeBinding>
    ) -> Path;

    fn qpath(
        &self, 
        self_type: P<Ty>, 
        trait_path: Path, 
        ident: Ident
    ) -> (QSelf, Path);

    fn qpath_all(
        &self, 
        self_type: P<Ty>, 
        trait_path: Path, 
        ident: Ident, 
        args: Vec<GenericArg>, 
        bindings: Vec<TypeBinding>
    ) -> (QSelf, Path);

    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_ident(&self, span: Span, idents: Ident) -> P<Ty>;

    fn anon_const(&self, span: Span, expr: ExprKind) -> AnonConst;

    fn const_ident(&self, span: Span, idents: Ident) -> AnonConst;

    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 typaram(
        &self, 
        span: Span, 
        id: Ident, 
        attrs: Vec<Attribute>, 
        bounds: GenericBounds, 
        default: Option<P<Ty>>
    ) -> GenericParam;

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

    fn poly_trait_ref(&self, span: Span, path: Path) -> PolyTraitRef;

    fn trait_bound(&self, path: Path) -> GenericBound;

    fn lifetime(&self, span: Span, ident: Ident) -> Lifetime;

    fn lifetime_def(
        &self, 
        span: Span, 
        ident: Ident, 
        attrs: Vec<Attribute>, 
        bounds: GenericBounds
    ) -> GenericParam;

    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(&self, span: Span, stmts: Vec<Stmt>) -> P<Block>;

    fn block_expr(&self, expr: P<Expr>) -> 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>;

    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_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: 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_u8(&self, sp: Span, u: u8) -> P<Expr>;

    fn expr_u16(&self, sp: Span, u: u16) -> P<Expr>;

    fn expr_u32(&self, sp: Span, u: u32) -> 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: Symbol) -> 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: Symbol) -> 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: 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>, 
        body: P<Expr>, 
        fn_decl_span: Span
    ) -> P<Expr>;

    fn lambda(&self, span: Span, ids: Vec<Ident>, body: P<Expr>) -> P<Expr>;

    fn lambda0(&self, span: Span, body: P<Expr>) -> P<Expr>;

    fn lambda1(&self, span: Span, body: P<Expr>, ident: Ident) -> P<Expr>;

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

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

    fn fn_decl(&self, inputs: Vec<Arg>, output: FunctionRetTy) -> 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: VariantData, 
        generics: Generics
    ) -> P<Item>;

    fn item_struct(
        &self, 
        span: Span, 
        name: Ident, 
        struct_def: VariantData
    ) -> P<Item>;

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

    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: MetaItem) -> Attribute;

    fn meta_word(&self, sp: Span, w: Name) -> MetaItem;

    fn meta_list_item_word(&self, sp: Span, w: Name) -> NestedMetaItem;

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

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

    fn item_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> P<Item>;

    fn item_use_simple_(
        &self, 
        sp: Span, 
        vis: Visibility, 
        ident: Option<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>,
    args: Vec<GenericArg>,
    bindings: Vec<TypeBinding>
) -> Path

fn qpath(
    &self,
    self_type: P<Ty>,
    trait_path: Path,
    ident: Ident
) -> (QSelf, Path)

fn qpath_all(
    &self,
    self_type: P<Ty>,
    trait_path: Path,
    ident: Ident,
    args: Vec<GenericArg>,
    bindings: Vec<TypeBinding>
) -> (QSelf, Path)

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_ident(&self, span: Span, idents: Ident) -> P<Ty>

fn anon_const(&self, span: Span, expr: ExprKind) -> AnonConst

fn const_ident(&self, span: Span, idents: Ident) -> AnonConst

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 typaram(
    &self,
    span: Span,
    id: Ident,
    attrs: Vec<Attribute>,
    bounds: GenericBounds,
    default: Option<P<Ty>>
) -> GenericParam

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

fn poly_trait_ref(&self, span: Span, path: Path) -> PolyTraitRef

fn trait_bound(&self, path: Path) -> GenericBound

fn lifetime(&self, span: Span, ident: Ident) -> Lifetime

fn lifetime_def(
    &self,
    span: Span,
    ident: Ident,
    attrs: Vec<Attribute>,
    bounds: GenericBounds
) -> GenericParam

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(&self, span: Span, stmts: Vec<Stmt>) -> P<Block>

fn block_expr(&self, expr: P<Expr>) -> 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>

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_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: 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_u8(&self, sp: Span, u: u8) -> P<Expr>

fn expr_u16(&self, sp: Span, u: u16) -> P<Expr>

fn expr_u32(&self, sp: Span, u: u32) -> 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: Symbol) -> 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: Symbol) -> 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: 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>,
    body: P<Expr>,
    fn_decl_span: Span
) -> P<Expr>

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

fn lambda0(&self, span: Span, body: P<Expr>) -> P<Expr>

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

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

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

fn fn_decl(&self, inputs: Vec<Arg>, output: FunctionRetTy) -> 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: VariantData,
    generics: Generics
) -> P<Item>

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

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>

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: MetaItem) -> Attribute

fn meta_word(&self, sp: Span, w: Name) -> MetaItem

fn meta_list_item_word(&self, sp: Span, w: Name) -> NestedMetaItem

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

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>

fn item_use_simple(&self, sp: Span, vis: Visibility, path: Path) -> P<Item>

fn item_use_simple_(
    &self,
    sp: Span,
    vis: Visibility,
    ident: Option<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>

Loading content...

Implementors

impl<'a> AstBuilder for ExtCtxt<'a>[src]

fn qpath(
    &self,
    self_type: P<Ty>,
    trait_path: Path,
    ident: Ident
) -> (QSelf, Path)[src]

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]

Constructs a qualified path.

Constructs a path like <self_type as trait_path>::ident<'a, T, A = Bar>.

fn expr_qpath(&self, span: Span, qself: QSelf, path: Path) -> P<Expr>[src]

Constructs a QPath expression.

Loading content...