Struct c2rust_ast_builder::Builder

pub struct Builder { /* fields omitted */ }

Methods

impl Builder

pub fn new() -> Builder

pub fn vis<V: Make<Visibility>>(self, vis: V) -> Self

pub fn pub_(self) -> Self

pub fn set_mutbl<M: Make<Mutability>>(self, mutbl: M) -> Self

pub fn mutbl(self) -> Self

pub fn unsafety<U: Make<Unsafety>>(self, unsafety: U) -> Self

pub fn unsafe_(self) -> Self

pub fn constness<C: Make<Constness>>(self, constness: C) -> Self

pub fn const_(self) -> Self

pub fn abi<A: Make<Abi>>(self, abi: A) -> Self

pub fn span<S: Make<Span>>(self, span: S) -> Self

pub fn id(self, id: NodeId) -> Self

Set the NodeId of the constructed AST.

Warning: Be careful with this option! Parts of the rewriter expect nodes with matching NodeIds to be identical in other ways as well. For best results, only call this method with fresh NodeIds, like those returned by st.next_node_id().

pub fn str_attr<K, V>(self, key: K, value: V) -> Self where
    K: Make<PathSegment>,
    V: IntoSymbol, 

pub fn single_attr<K>(self, key: K) -> Self where
    K: Make<PathSegment>, 

pub fn call_attr<K, V>(self, func: K, arguments: Vec<V>) -> Self where
    K: Make<PathSegment>,
    V: Make<Ident>, 

pub fn path_segment_with_args<I, P>(self, identifier: I, args: P) -> PathSegment where
    I: Make<Ident>,
    P: Make<GenericArgs>, 

pub fn parenthesized_args<Ts>(self, tys: Ts) -> ParenthesizedArgs where
    Ts: Make<Vec<P<Ty>>>, 

pub fn angle_bracketed_args<A>(self, args: Vec<A>) -> AngleBracketedArgs where
    A: Make<GenericArg>, 

pub fn generic_arg<A>(self, arg: A) -> GenericArg where
    A: Make<GenericArg>, 

pub fn ident<I>(self, name: I) -> Ident where
    I: Make<Ident>, 

pub fn path_segment<S>(self, seg: S) -> PathSegment where
    S: Make<PathSegment>, 

pub fn path<Pa>(self, path: Pa) -> Path where
    Pa: Make<Path>, 

pub fn abs_path<Pa>(self, path: Pa) -> Path where
    Pa: Make<Path>, 

pub fn anon_const<E>(self, expr: E) -> AnonConst where
    E: Make<P<Expr>>, 

pub fn spanned<T, U: Make<T>>(self, x: U) -> Spanned<T>

pub fn array_expr<A>(self, args: Vec<A>) -> P<Expr> where
    A: Make<P<Expr>>, 

pub fn call_expr<F, A>(self, func: F, args: Vec<A>) -> P<Expr> where
    F: Make<P<Expr>>,
    A: Make<P<Expr>>, 

pub fn method_call_expr<E, S, A>(self, expr: E, seg: S, args: Vec<A>) -> P<Expr> where
    E: Make<P<Expr>>,
    S: Make<PathSegment>,
    A: Make<P<Expr>>, 

pub fn tuple_expr<E>(self, exprs: Vec<E>) -> P<Expr> where
    E: Make<P<Expr>>, 

pub fn binary_expr<O, E>(self, op: O, lhs: E, rhs: E) -> P<Expr> where
    O: Make<BinOpKind>,
    E: Make<P<Expr>>, 

pub fn unary_expr<O, E>(self, op: O, a: E) -> P<Expr> where
    O: Make<UnOp>,
    E: Make<P<Expr>>, 

pub fn lit_expr<L>(self, lit: L) -> P<Expr> where
    L: Make<Lit>, 

pub fn cast_expr<E, T>(self, e: E, t: T) -> P<Expr> where
    E: Make<P<Expr>>,
    T: Make<P<Ty>>, 

pub fn type_expr<E, T>(self, e: E, t: T) -> P<Expr> where
    E: Make<P<Expr>>,
    T: Make<P<Ty>>, 

pub fn block_expr<B>(self, blk: B) -> P<Expr> where
    B: Make<P<Block>>, 

pub fn labelled_block_expr<B, L>(self, blk: B, lbl: L) -> P<Expr> where
    B: Make<P<Block>>,
    L: Make<Label>, 

pub fn assign_expr<E1, E2>(self, lhs: E1, rhs: E2) -> P<Expr> where
    E1: Make<P<Expr>>,
    E2: Make<P<Expr>>, 

pub fn assign_op_expr<O, E1, E2>(self, op: O, lhs: E1, rhs: E2) -> P<Expr> where
    O: Make<BinOpKind>,
    E1: Make<P<Expr>>,
    E2: Make<P<Expr>>, 

pub fn index_expr<E1, E2>(self, lhs: E1, rhs: E2) -> P<Expr> where
    E1: Make<P<Expr>>,
    E2: Make<P<Expr>>, 

pub fn path_expr<Pa>(self, path: Pa) -> P<Expr> where
    Pa: Make<Path>, 

pub fn qpath_expr<Pa>(self, qself: Option<QSelf>, path: Pa) -> P<Expr> where
    Pa: Make<Path>, 

pub fn repeat_expr<E, N>(self, expr: E, n: N) -> P<Expr> where
    E: Make<P<Expr>>,
    N: Make<P<Expr>>, 

An array literal constructed from one repeated element. [expr; n]

pub fn paren_expr<E>(self, e: E) -> P<Expr> where
    E: Make<P<Expr>>, 

pub fn ident_expr<I>(self, name: I) -> P<Expr> where
    I: Make<Ident>, 

pub fn addr_of_expr<E>(self, e: E) -> P<Expr> where
    E: Make<P<Expr>>, 

pub fn mac_expr<M>(self, mac: M) -> P<Expr> where
    M: Make<Mac>, 

pub fn struct_expr<Pa>(self, path: Pa, fields: Vec<Field>) -> P<Expr> where
    Pa: Make<Path>, 

pub fn struct_expr_base<Pa, E>(
    self,
    path: Pa,
    fields: Vec<Field>,
    base: Option<E>
) -> P<Expr> where
    Pa: Make<Path>,
    E: Make<P<Expr>>, 

pub fn field_expr<E, F>(self, val: E, field: F) -> P<Expr> where
    E: Make<P<Expr>>,
    F: Make<Ident>, 

pub fn field<I, E>(self, ident: I, expr: E) -> Field where
    I: Make<Ident>,
    E: Make<P<Expr>>, 

pub fn match_expr<E>(self, cond: E, arms: Vec<Arm>) -> P<Expr> where
    E: Make<P<Expr>>, 

pub fn arm<Pa, E>(self, pats: Vec<Pa>, guard: Option<E>, body: E) -> Arm where
    E: Make<P<Expr>>,
    Pa: Make<P<Pat>>, 

pub fn bytestr_lit(self, s: Vec<u8>) -> Lit

pub fn str_lit<S>(self, s: S) -> Lit where
    S: IntoSymbol, 

pub fn byte_lit(self, b: u8) -> Lit

pub fn char_lit(self, c: char) -> Lit

pub fn int_lit<T>(self, i: u128, ty: T) -> Lit where
    T: Make<LitIntType>, 

pub fn float_lit<S, T>(self, s: S, ty: T) -> Lit where
    S: IntoSymbol,
    T: Make<FloatTy>, 

pub fn float_unsuffixed_lit<S>(self, s: S) -> Lit where
    S: IntoSymbol, 

pub fn bool_lit(self, b: bool) -> Lit

pub fn ifte_expr<C, T, E>(
    self,
    cond: C,
    then_case: T,
    else_case: Option<E>
) -> P<Expr> where
    C: Make<P<Expr>>,
    T: Make<P<Block>>,
    E: Make<P<Expr>>, 

pub fn while_expr<C, B, I>(self, cond: C, body: B, label: Option<I>) -> P<Expr> where
    C: Make<P<Expr>>,
    B: Make<P<Block>>,
    I: Make<Ident>, 

pub fn loop_expr<B, I>(self, body: B, label: Option<I>) -> P<Expr> where
    B: Make<P<Block>>,
    I: Make<Ident>, 

pub fn for_expr<Pa, E, B, I>(
    self,
    pat: Pa,
    expr: E,
    body: B,
    label: Option<I>
) -> P<Expr> where
    Pa: Make<P<Pat>>,
    E: Make<P<Expr>>,
    B: Make<P<Block>>,
    I: Make<Ident>, 

pub fn ident_pat<I>(self, name: I) -> P<Pat> where
    I: Make<Ident>, 

pub fn tuple_pat<Pa>(self, pats: Vec<Pa>) -> P<Pat> where
    Pa: Make<P<Pat>>, 

pub fn qpath_pat<Pa>(self, qself: Option<QSelf>, path: Pa) -> P<Pat> where
    Pa: Make<Path>, 

pub fn wild_pat(self) -> P<Pat>

pub fn lit_pat<L>(self, lit: L) -> P<Pat> where
    L: Make<P<Expr>>, 

pub fn mac_pat<M>(self, mac: M) -> P<Pat> where
    M: Make<Mac>, 

pub fn ident_ref_pat<I>(self, name: I) -> P<Pat> where
    I: Make<Ident>, 

pub fn barefn_ty<T>(self, decl: T) -> P<Ty> where
    T: Make<P<FnDecl>>, 

pub fn array_ty<T, E>(self, ty: T, len: E) -> P<Ty> where
    T: Make<P<Ty>>,
    E: Make<P<Expr>>, 

pub fn slice_ty<T>(self, ty: T) -> P<Ty> where
    T: Make<P<Ty>>, 

pub fn ptr_ty<T>(self, ty: T) -> P<Ty> where
    T: Make<P<Ty>>, 

pub fn ref_ty<T>(self, ty: T) -> P<Ty> where
    T: Make<P<Ty>>, 

pub fn ref_lt_ty<L, T>(self, lt: L, ty: T) -> P<Ty> where
    L: Make<Lifetime>,
    T: Make<P<Ty>>, 

pub fn never_ty(self) -> P<Ty>

pub fn tuple_ty<T>(self, elem_tys: Vec<T>) -> P<Ty> where
    T: Make<P<Ty>>, 

pub fn path_ty<Pa>(self, path: Pa) -> P<Ty> where
    Pa: Make<Path>, 

pub fn qpath_ty<Pa>(self, qself: Option<QSelf>, path: Pa) -> P<Ty> where
    Pa: Make<Path>, 

pub fn ident_ty<I>(self, name: I) -> P<Ty> where
    I: Make<Ident>, 

pub fn infer_ty(self) -> P<Ty>

pub fn mac_ty<M>(self, mac: M) -> P<Ty> where
    M: Make<Mac>, 

pub fn cvar_args_ty(self) -> P<Ty>

pub fn local_stmt<L>(self, local: L) -> Stmt where
    L: Make<P<Local>>, 

pub fn expr_stmt<E>(self, expr: E) -> Stmt where
    E: Make<P<Expr>>, 

pub fn semi_stmt<E>(self, expr: E) -> Stmt where
    E: Make<P<Expr>>, 

pub fn item_stmt<I>(self, item: I) -> Stmt where
    I: Make<P<Item>>, 

pub fn mac_stmt<M>(self, mac: M) -> Stmt where
    M: Make<Mac>, 

pub fn static_item<I, T, E>(self, name: I, ty: T, init: E) -> P<Item> where
    I: Make<Ident>,
    T: Make<P<Ty>>,
    E: Make<P<Expr>>, 

pub fn const_item<I, T, E>(self, name: I, ty: T, init: E) -> P<Item> where
    I: Make<Ident>,
    T: Make<P<Ty>>,
    E: Make<P<Expr>>, 

pub fn fn_item<I, D, B>(self, name: I, decl: D, block: B) -> P<Item> where
    I: Make<Ident>,
    D: Make<P<FnDecl>>,
    B: Make<P<Block>>, 

pub fn fn_decl(
    self,
    inputs: Vec<Arg>,
    output: FunctionRetTy,
    c_variadic: bool
) -> P<FnDecl>

pub fn struct_item<I>(self, name: I, fields: Vec<StructField>) -> P<Item> where
    I: Make<Ident>, 

pub fn union_item<I>(self, name: I, fields: Vec<StructField>) -> P<Item> where
    I: Make<Ident>, 

pub fn enum_item<I>(self, name: I, fields: Vec<Variant>) -> P<Item> where
    I: Make<Ident>, 

pub fn type_item<I, T>(self, name: I, ty: T) -> P<Item> where
    I: Make<Ident>,
    T: Make<P<Ty>>, 

pub fn mod_item<I>(self, name: I, m: Mod) -> P<Item> where
    I: Make<Ident>, 

pub fn mod_<I>(self, items: Vec<I>) -> Mod where
    I: Make<P<Item>>, 

pub fn mac_item<M>(self, mac: M) -> P<Item> where
    M: Make<Mac>, 

pub fn variant<I>(self, name: I, dat: VariantData) -> Variant where
    I: Make<Ident>, 

pub fn unit_variant<I, E>(self, name: I, disc: Option<E>) -> Variant where
    I: Make<Ident>,
    E: Make<P<Expr>>, 

pub fn impl_item<T>(self, ty: T, items: Vec<ImplItem>) -> P<Item> where
    T: Make<P<Ty>>, 

pub fn extern_crate_item<I>(self, name: I, rename: Option<I>) -> P<Item> where
    I: Make<Ident>, 

pub fn use_item<Pa, I>(self, path: Pa, rename: Option<I>) -> P<Item> where
    Pa: Make<Path>,
    I: Make<Ident>, 

pub fn use_multiple_item<Pa, I>(self, path: Pa, inner: Vec<I>) -> P<Item> where
    Pa: Make<Path>,
    I: Make<Ident>, 

pub fn foreign_items(self, items: Vec<ForeignItem>) -> P<Item>

pub fn mac_impl_item<M>(self, mac: M) -> ImplItem where
    M: Make<Mac>, 

pub fn mac_trait_item<M>(self, mac: M) -> TraitItem where
    M: Make<Mac>, 

pub fn fn_foreign_item<I, D>(self, name: I, decl: D) -> ForeignItem where
    I: Make<Ident>,
    D: Make<P<FnDecl>>, 

pub fn static_foreign_item<I, T>(self, name: I, ty: T) -> ForeignItem where
    I: Make<Ident>,
    T: Make<P<Ty>>, 

pub fn ty_foreign_item<I>(self, name: I) -> ForeignItem where
    I: Make<Ident>, 

pub fn mac_foreign_item<M>(self, mac: M) -> ForeignItem where
    M: Make<Mac>, 

pub fn struct_field<I, T>(self, ident: I, ty: T) -> StructField where
    I: Make<Ident>,
    T: Make<P<Ty>>, 

pub fn enum_field<T>(self, ty: T) -> StructField where
    T: Make<P<Ty>>, 

pub fn block<S>(self, stmts: Vec<S>) -> P<Block> where
    S: Make<Stmt>, 

pub fn label<L>(self, lbl: L) -> Label where
    L: Make<Label>, 

pub fn break_expr_value<L, E>(
    self,
    label: Option<L>,
    value: Option<E>
) -> P<Expr> where
    L: Make<Label>,
    E: Make<P<Expr>>, 

pub fn arg<T, Pt>(self, ty: T, pat: Pt) -> Arg where
    T: Make<P<Ty>>,
    Pt: Make<P<Pat>>, 

pub fn self_arg<S>(self, kind: S) -> Arg where
    S: Make<SelfKind>, 

pub fn ty_param<I>(self, ident: I) -> GenericParam where
    I: Make<Ident>, 

pub fn ty<T>(self, node: TyKind) -> Ty

pub fn attribute<Pa, Ts>(
    self,
    style: AttrStyle,
    path: Pa,
    tokens: Ts
) -> Attribute where
    Pa: Make<Path>,
    Ts: Make<TokenStream>, 

pub fn meta_item_attr(self, style: AttrStyle, meta_item: MetaItem) -> Self

pub fn meta_item<I, K>(self, path: I, kind: K) -> MetaItem where
    I: Make<Path>,
    K: Make<MetaItemKind>, 

pub fn nested_meta_item<K>(self, kind: K) -> NestedMetaItem where
    K: Make<NestedMetaItem>, 

pub fn as_inner_attrs(self) -> Vec<Attribute>

pub fn mac<Pa, Ts>(self, path: Pa, tts: Ts, delim: MacDelimiter) -> Mac where
    Pa: Make<Path>,
    Ts: Make<TokenStream>, 

pub fn local<V, T, E>(self, pat: V, ty: Option<T>, init: Option<E>) -> Local where
    V: Make<P<Pat>>,
    T: Make<P<Ty>>,
    E: Make<P<Expr>>, 

Create a local variable

pub fn return_expr<E>(self, val: Option<E>) -> P<Expr> where
    E: Make<P<Expr>>, 

pub fn continue_expr<I>(self, label: Option<I>) -> P<Expr> where
    I: Make<Ident>, 

pub fn break_expr<I>(self, label: Option<I>) -> P<Expr> where
    I: Make<Ident>, 

pub fn closure_expr<D, E>(
    self,
    capture: CaptureBy,
    mov: Movability,
    decl: D,
    body: E
) -> P<Expr> where
    D: Make<P<FnDecl>>,
    E: Make<P<Expr>>, 

Trait Implementations

impl Clone for Builder

fn clone(&self) -> Builder

Returns a copy of the value.

default fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Builder

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.