Struct c2rust_ast_builder::Builder
source · pub struct Builder { /* private fields */ }
Implementations§
source§impl Builder
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 extern_<A: Make<Extern>>(self, ext: A) -> Self
pub fn span<S: Make<Span>>(self, span: S) -> Self
pub fn generic_over(self, param: GenericParam) -> Self
pub fn prepare_meta_namevalue(&self, mnv: MetaNameValue) -> PreparedMetaItem
pub fn prepare_meta_list(&self, list: MetaList) -> PreparedMetaItem
pub fn prepare_meta_path<I>(&self, path: I) -> PreparedMetaItemwhere I: Make<Path>,
pub fn prepare_meta(&self, kind: Meta) -> PreparedMetaItem
pub fn prepare_nested_meta_item<I>( &self, path: I, kind: Meta ) -> PreparedMetaItemwhere I: Make<Path>,
pub fn prepared_attr(self, prepared: PreparedMetaItem) -> Self
pub fn str_attr<K, V>(self, key: K, value: V) -> Selfwhere K: Make<Path>, V: Make<Lit>,
pub fn single_attr<K>(self, key: K) -> Selfwhere K: Make<PathSegment>,
pub fn call_attr<K, V>(self, func: K, arguments: Vec<V>) -> Selfwhere K: Make<PathSegment>, V: Make<Ident>,
pub fn path_segment_with_args<I, P>(self, identifier: I, args: P) -> PathSegmentwhere I: Make<Ident>, P: Make<PathArguments>,
pub fn parenthesized_args( self, tys: Vec<Box<Type>> ) -> ParenthesizedGenericArguments
pub fn angle_bracketed_args<A>( self, args: Vec<A> ) -> AngleBracketedGenericArgumentswhere A: Make<GenericArgument>,
pub fn generic_arg<A>(self, arg: A) -> GenericArgumentwhere A: Make<GenericArgument>,
pub fn ident<I>(self, name: I) -> Identwhere I: Make<Ident>,
pub fn path_segment<S>(self, seg: S) -> PathSegmentwhere S: Make<PathSegment>,
pub fn path<Pa>(self, path: Pa) -> Pathwhere Pa: Make<Path>,
pub fn use_tree<Pa>(self, prefix: Pa, tree: UseTree) -> UseTreewhere Pa: Make<Path>,
pub fn abs_path<Pa>(self, path: Pa) -> Pathwhere Pa: Make<Path>,
pub fn array_expr(self, args: Vec<Box<Expr>>) -> Box<Expr>
pub fn call_expr(self, func: Box<Expr>, args: Vec<Box<Expr>>) -> Box<Expr>
pub fn method_call_expr<S>( self, expr: Box<Expr>, seg: S, args: Vec<Box<Expr>> ) -> Box<Expr>where S: Make<PathSegment>,
pub fn tuple_expr(self, exprs: Vec<Box<Expr>>) -> Box<Expr>
pub fn binary_expr(self, op: BinOp, lhs: Box<Expr>, rhs: Box<Expr>) -> Box<Expr>
pub fn unary_expr<O>(self, op: O, a: Box<Expr>) -> Box<Expr>where O: Make<UnOp>,
pub fn lit_expr<L>(self, lit: L) -> Box<Expr>where L: Make<Lit>,
pub fn cast_expr(self, e: Box<Expr>, t: Box<Type>) -> Box<Expr>
pub fn type_expr(self, e: Box<Expr>, t: Box<Type>) -> Box<Expr>
pub fn unsafe_block_expr(self, unsafe_blk: ExprUnsafe) -> Box<Expr>
pub fn block_expr(self, block: Block) -> Box<Expr>
pub fn labelled_block_expr<L>(self, block: Block, lbl: L) -> Box<Expr>where L: Make<Label>,
pub fn assign_expr(self, lhs: Box<Expr>, rhs: Box<Expr>) -> Box<Expr>
pub fn assign_op_expr( self, op: BinOp, lhs: Box<Expr>, rhs: Box<Expr> ) -> Box<Expr>
pub fn index_expr(self, lhs: Box<Expr>, rhs: Box<Expr>) -> Box<Expr>
pub fn abs_path_expr<Pa>(self, path: Pa) -> Box<Expr>where Pa: Make<Path>,
pub fn path_expr<Pa>(self, path: Pa) -> Box<Expr>where Pa: Make<Path>,
pub fn qpath_expr<Pa>(self, qself: Option<QSelf>, path: Pa) -> Box<Expr>where Pa: Make<Path>,
sourcepub fn repeat_expr(self, expr: Box<Expr>, n: Box<Expr>) -> Box<Expr>
pub fn repeat_expr(self, expr: Box<Expr>, n: Box<Expr>) -> Box<Expr>
An array literal constructed from one repeated element.
[expr; n]
pub fn paren_expr(self, e: Box<Expr>) -> Box<Expr>
pub fn ident_expr<I>(self, name: I) -> Box<Expr>where I: Make<Ident>,
pub fn addr_of_expr(self, e: Box<Expr>) -> Box<Expr>
pub fn mac_expr(self, mac: Macro) -> Box<Expr>
pub fn struct_expr<Pa>(self, path: Pa, fields: Vec<FieldValue>) -> Box<Expr>where Pa: Make<Path>,
pub fn struct_expr_base<Pa>( self, path: Pa, fields: Vec<FieldValue>, base: Option<Box<Expr>> ) -> Box<Expr>where Pa: Make<Path>,
pub fn field_expr<F>(self, val: Box<Expr>, field: F) -> Box<Expr>where F: Make<Ident>,
pub fn anon_field_expr(self, val: Box<Expr>, field: u32) -> Box<Expr>
pub fn field<I>(self, ident: I, expr: Box<Expr>) -> FieldValuewhere I: Make<Ident>,
pub fn match_expr(self, cond: Box<Expr>, arms: Vec<Arm>) -> Box<Expr>
pub fn arm(self, pat: Pat, guard: Option<Box<Expr>>, body: Box<Expr>) -> Arm
pub fn int_lit(self, i: u128, ty: &str) -> Lit
pub fn int_unsuffixed_lit(self, i: u128) -> Lit
pub fn float_lit(self, s: &str, ty: &str) -> Lit
pub fn float_unsuffixed_lit(self, s: &str) -> Lit
pub fn bool_lit(self, b: bool) -> Lit
pub fn ifte_expr( self, cond: Box<Expr>, then_branch: Block, else_branch: Option<Box<Expr>> ) -> Box<Expr>
pub fn while_expr<I>( self, cond: Box<Expr>, body: Block, label: Option<I> ) -> Box<Expr>where I: Make<Ident>,
pub fn loop_expr<I>(self, body: Block, label: Option<I>) -> Box<Expr>where I: Make<Ident>,
pub fn for_expr<I>( self, pat: Pat, expr: Box<Expr>, body: Block, label: Option<I> ) -> Box<Expr>where I: Make<Ident>,
pub fn ident_pat<I>(self, name: I) -> Patwhere I: Make<Ident>,
pub fn tuple_pat(self, pats: Vec<Pat>) -> Pat
pub fn qpath_pat<Pa>(self, qself: Option<QSelf>, path: Pa) -> Box<Pat>where Pa: Make<Path>,
pub fn wild_pat(self) -> Pat
pub fn lit_pat(self, lit: Box<Expr>) -> Pat
pub fn mac_pat(self, mac: Macro) -> Pat
pub fn ident_ref_pat<I>(self, name: I) -> Patwhere I: Make<Ident>,
pub fn or_pat(self, pats: Vec<Pat>) -> Pat
pub fn barefn_ty( self, decl: (Vec<BareFnArg>, Option<Variadic>, ReturnType) ) -> Box<Type>
pub fn array_ty(self, ty: Box<Type>, len: Box<Expr>) -> Box<Type>
pub fn slice_ty(self, ty: Box<Type>) -> Box<Type>
pub fn ptr_ty(self, ty: Box<Type>) -> Box<Type>
pub fn ref_ty(self, ty: Box<Type>) -> Box<Type>
pub fn ref_lt_ty<L>(self, lt: L, ty: Box<Type>) -> Box<Type>where L: Make<Lifetime>,
pub fn never_ty(self) -> Box<Type>
pub fn tuple_ty(self, elem_tys: Vec<Box<Type>>) -> Box<Type>
pub fn path_ty<Pa>(self, path: Pa) -> Box<Type>where Pa: Make<Path>,
pub fn qpath_ty<Pa>(self, qself: Option<QSelf>, path: Pa) -> Box<Type>where Pa: Make<Path>,
pub fn ident_ty<I>(self, name: I) -> Box<Type>where I: Make<Ident>,
pub fn infer_ty(self) -> Box<Type>
pub fn mac_ty(self, mac: Macro) -> Box<Type>
pub fn cvar_args_ty(self) -> Box<Type>
pub fn local_stmt(self, local: Box<Local>) -> Stmt
pub fn expr_stmt(self, expr: Box<Expr>) -> Stmt
pub fn semi_stmt(self, expr: Box<Expr>) -> Stmt
pub fn item_stmt(self, item: Box<Item>) -> Stmt
pub fn mac_stmt(self, mac: Macro) -> Stmt
pub fn static_item<I>( self, name: I, ty: Box<Type>, init: Box<Expr> ) -> Box<Item>where I: Make<Ident>,
pub fn const_item<I>(self, name: I, ty: Box<Type>, init: Box<Expr>) -> Box<Item>where I: Make<Ident>,
pub fn fn_item<S>(self, sig: S, block: Block) -> Box<Item>where S: Make<Signature>,
pub fn variadic_arg(self, variadic_attrs: Vec<Attribute>) -> Variadic
pub fn fn_decl<I>( self, name: I, inputs: Vec<FnArg>, variadic: Option<Variadic>, output: ReturnType ) -> Box<(Ident, Vec<FnArg>, Option<Variadic>, ReturnType)>where I: Make<Ident>,
pub fn struct_item<I>( self, name: I, fields: Vec<Field>, is_tuple: bool ) -> Box<Item>where I: Make<Ident>,
pub fn union_item<I>(self, name: I, fields: Vec<Field>) -> Box<Item>where I: Make<Ident>,
pub fn enum_item<I>(self, name: I, fields: Vec<Variant>) -> Box<Item>where I: Make<Ident>,
pub fn type_item<I>(self, name: I, ty: Box<Type>) -> Box<Item>where I: Make<Ident>,
pub fn mod_item<I>(self, name: I, items: Option<Vec<Item>>) -> Box<Item>where I: Make<Ident>,
pub fn mod_(self, items: Vec<Box<Item>>) -> Vec<Item>
pub fn mac_item(self, mac: Macro) -> Box<Item>
pub fn variant<I>(self, name: I, fields: Fields) -> Variantwhere I: Make<Ident>,
pub fn unit_variant<I>(self, name: I, disc: Option<Box<Expr>>) -> Variantwhere I: Make<Ident>,
pub fn impl_item(self, ty: Box<Type>, items: Vec<ImplItem>) -> Box<Item>
pub fn extern_crate_item<I>(self, name: I, rename: Option<I>) -> Box<Item>where I: Make<Ident>,
pub fn use_item(self, tree: UseTree) -> Box<Item>
pub fn use_simple_item<Pa, I>(self, path: Pa, rename: Option<I>) -> Box<Item>where Pa: Make<Path>, I: Make<Ident>,
pub fn use_multiple_item<Pa, I, It>(self, path: Pa, inner: It) -> Box<Item>where Pa: Make<Path>, I: Make<Ident>, It: Iterator<Item = I>,
pub fn use_glob_item<Pa>(self, path: Pa) -> Box<Item>where Pa: Make<Path>,
pub fn foreign_items(self, items: Vec<ForeignItem>) -> Box<Item>
pub fn get_abi(&self) -> Abi
pub fn get_abi_opt(&self) -> Option<Abi>
pub fn mac_impl_item(self, mac: Macro) -> ImplItem
pub fn mac_trait_item(self, mac: Macro) -> TraitItem
sourcepub fn fn_foreign_item(
self,
decl: Box<(Ident, Vec<FnArg>, Option<Variadic>, ReturnType)>
) -> Box<ForeignItem>
pub fn fn_foreign_item( self, decl: Box<(Ident, Vec<FnArg>, Option<Variadic>, ReturnType)> ) -> Box<ForeignItem>
ForeignItem
is large (472 bytes), so Box
it.
sourcepub fn static_foreign_item<I>(self, name: I, ty: Box<Type>) -> Box<ForeignItem>where
I: Make<Ident>,
pub fn static_foreign_item<I>(self, name: I, ty: Box<Type>) -> Box<ForeignItem>where I: Make<Ident>,
ForeignItem
is large (472 bytes), so Box
it.
sourcepub fn ty_foreign_item<I>(self, name: I) -> Box<ForeignItem>where
I: Make<Ident>,
pub fn ty_foreign_item<I>(self, name: I) -> Box<ForeignItem>where I: Make<Ident>,
ForeignItem
is large (472 bytes), so Box
it.
pub fn mac_foreign_item(self, mac: Macro) -> ForeignItem
pub fn struct_field<I>(self, ident: I, ty: Box<Type>) -> Fieldwhere I: Make<Ident>,
pub fn enum_field(self, ty: Box<Type>) -> Field
pub fn unsafe_block(self, stmts: Vec<Stmt>) -> ExprUnsafe
pub fn block(self, stmts: Vec<Stmt>) -> Block
pub fn label<L>(self, lbl: L) -> Labelwhere L: Make<Label>,
pub fn break_expr_value<L>( self, label: Option<L>, value: Option<Box<Expr>> ) -> Box<Expr>where L: Make<Label>,
pub fn bare_arg<I>(self, ty: Box<Type>, name: Option<I>) -> BareFnArgwhere I: Make<Box<Ident>>,
pub fn arg(self, ty: Box<Type>, pat: Pat) -> FnArg
pub fn self_arg(self, kind: SelfKind) -> FnArg
pub fn ty_param<I>(self, ident: I) -> GenericParamwhere I: Make<Ident>,
pub fn ty<T>(self, kind: Type) -> Type
pub fn lt_param<L>(self, lifetime: L) -> GenericParamwhere L: Make<Lifetime>,
pub fn lifetime<L: Make<Lifetime>>(self, lt: L) -> Lifetime
pub fn attribute<Pa, Ma>( self, style: AttrStyle, path: Pa, args: Ma ) -> Attributewhere Pa: Make<Path>, Ma: Make<TokenStream>,
pub fn meta_item_attr(self, style: AttrStyle, meta_item: Meta) -> Self
pub fn meta_path<Pa>(self, path: Pa) -> Metawhere Pa: Make<Path>,
pub fn meta_list<I, N>(self, path: I, args: N) -> Metawhere I: Make<Path>, N: Make<Vec<NestedMeta>>,
pub fn meta_namevalue<K, V>(self, key: K, value: V) -> Metawhere K: Make<Path>, V: Make<Lit>,
pub fn nested_meta_item<K>(self, kind: K) -> NestedMetawhere K: Make<NestedMeta>,
pub fn as_inner_attrs(self) -> Vec<Attribute>
pub fn into_attrs(self) -> Vec<Attribute>
pub fn empty_mac<Pa>(self, path: Pa, delim: MacroDelimiter) -> Macrowhere Pa: Make<Path>,
pub fn mac<Ts>(self, func: Path, arguments: Ts, delim: MacroDelimiter) -> Macrowhere Ts: Make<TokenStream>,
sourcepub fn local(
self,
pat: Pat,
ty: Option<Box<Type>>,
init: Option<Box<Expr>>
) -> Local
pub fn local( self, pat: Pat, ty: Option<Box<Type>>, init: Option<Box<Expr>> ) -> Local
Create a local variable
pub fn return_expr(self, val: Option<Box<Expr>>) -> Box<Expr>
pub fn continue_expr<I>(self, label: Option<I>) -> Box<Expr>where I: Make<Ident>,
pub fn break_expr<I>(self, label: Option<I>) -> Box<Expr>where I: Make<Ident>,
pub fn closure_expr( self, capture: CaptureBy, mov: Movability, decl: (Ident, Vec<FnArg>, Option<Variadic>, ReturnType), body: Box<Expr> ) -> Box<Expr>
Trait Implementations§
Auto Trait Implementations§
impl RefUnwindSafe for Builder
impl !Send for Builder
impl !Sync for Builder
impl Unpin for Builder
impl UnwindSafe for Builder
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more