Struct aster::expr::ExprBuilder [] [src]

pub struct ExprBuilder<F = Identity> {
    // some fields omitted
}

Methods

impl ExprBuilder

fn new() -> Self

impl<F> ExprBuilder<F> where F: Invoke<P<Expr>>

fn with_callback(callback: F) -> Self

fn build(self, expr: P<Expr>) -> F::Result

fn span(self, span: Span) -> Self

fn with_attr(self, attr: Attribute) -> Self

fn attr(self) -> AttrBuilder<Self>

fn build_expr_kind(self, expr: ExprKind) -> F::Result

fn build_path(self, path: Path) -> F::Result

fn build_qpath(self, qself: QSelf, path: Path) -> F::Result

fn path(self) -> PathBuilder<Self>

fn qpath(self) -> QPathBuilder<Self>

fn id<I>(self, id: I) -> F::Result where I: ToIdent

fn build_lit(self, lit: P<Lit>) -> F::Result

fn lit(self) -> LitBuilder<Self>

fn bool(self, value: bool) -> F::Result

fn true_(self) -> F::Result

fn false_(self) -> F::Result

fn int(self, value: i64) -> F::Result

fn uint(self, value: u64) -> F::Result

fn isize(self, value: isize) -> F::Result

fn i8(self, value: i8) -> F::Result

fn i16(self, value: i16) -> F::Result

fn i32(self, value: i32) -> F::Result

fn i64(self, value: i64) -> F::Result

fn usize(self, value: usize) -> F::Result

fn u8(self, value: u8) -> F::Result

fn u16(self, value: u16) -> F::Result

fn u32(self, value: u32) -> F::Result

fn u64(self, value: u64) -> F::Result

fn f32<S>(self, value: S) -> F::Result where S: ToInternedString

fn f64<S>(self, value: S) -> F::Result where S: ToInternedString

fn str<S>(self, value: S) -> F::Result where S: ToInternedString

fn build_unary(self, unop: UnOp, expr: P<Expr>) -> F::Result

fn build_deref(self, expr: P<Expr>) -> F::Result

fn build_not(self, expr: P<Expr>) -> F::Result

fn build_neg(self, expr: P<Expr>) -> F::Result

fn unary(self, unop: UnOp) -> ExprBuilder<ExprUnaryBuilder<F>>

fn deref(self) -> ExprBuilder<ExprUnaryBuilder<F>>

fn not(self) -> ExprBuilder<ExprUnaryBuilder<F>>

fn neg(self) -> ExprBuilder<ExprUnaryBuilder<F>>

fn build_binary(self, binop: BinOpKind, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_add(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_sub(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_mul(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_div(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_rem(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_and(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_or(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_bit_xor(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_bit_and(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_bit_or(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_shl(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_shr(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_eq(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_lt(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_le(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_ne(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_ge(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn build_gt(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn binary(self, binop: BinOpKind) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn add(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn sub(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn mul(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn div(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn rem(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn and(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn or(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn bit_xor(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn bit_and(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn bit_or(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn shl(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn shr(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn eq(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn lt(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn le(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn ne(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn ge(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn gt(self) -> ExprBuilder<ExprBinaryLhsBuilder<F>>

fn ref_(self) -> ExprBuilder<ExprRefBuilder<F>>

fn mut_ref(self) -> ExprBuilder<ExprRefBuilder<F>>

fn break_(self) -> F::Result

fn break_to<I>(self, label: I) -> F::Result where I: ToIdent

fn continue_(self) -> F::Result

fn continue_to<I>(self, label: I) -> F::Result where I: ToIdent

fn return_(self) -> F::Result

fn return_expr(self) -> ExprBuilder<ExprReturnBuilder<F>>

fn unit(self) -> F::Result

fn tuple(self) -> ExprTupleBuilder<F>

fn struct_path<P>(self, path: P) -> ExprStructPathBuilder<F> where P: IntoPath

fn struct_id<T>(self, id: T) -> ExprStructPathBuilder<F> where T: ToIdent

fn struct_(self) -> PathBuilder<ExprStructBuilder<F>>

fn self_(self) -> F::Result

fn none(self) -> F::Result

fn some(self) -> ExprBuilder<ExprPathBuilder<F>>

fn ok(self) -> ExprBuilder<ExprPathBuilder<F>>

fn err(self) -> ExprBuilder<ExprPathBuilder<F>>

fn phantom_data(self) -> F::Result

fn call(self) -> ExprBuilder<ExprCallBuilder<F>>

fn method_call<I>(self, id: I) -> ExprBuilder<ExprMethodCallBuilder<F>> where I: ToIdent

fn build_block(self, block: P<Block>) -> F::Result

fn block(self) -> BlockBuilder<Self>

fn build_assign(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn assign(self) -> ExprBuilder<ExprAssignBuilder<F>>

fn build_assign_op(self, binop: BinOpKind, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn assign_op(self, binop: BinOpKind) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn add_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn sub_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn mul_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn rem_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn and_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn or_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn bit_xor_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn bit_and_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn bit_or_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn bit_shl_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn bit_shr_assign(self) -> ExprBuilder<ExprAssignOpBuilder<F>>

fn build_index(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn index(self) -> ExprBuilder<ExprIndexBuilder<F>>

fn build_repeat(self, lhs: P<Expr>, rhs: P<Expr>) -> F::Result

fn repeat(self) -> ExprBuilder<ExprRepeatBuilder<F>>

fn loop_(self) -> ExprLoopBuilder<F>

fn if_(self) -> ExprBuilder<ExprIfBuilder<F>>

fn match_(self) -> ExprBuilder<ExprMatchBuilder<F>>

fn paren(self) -> ExprBuilder<ExprParenBuilder<F>>

fn field<I>(self, id: I) -> ExprBuilder<ExprFieldBuilder<F>> where I: ToIdent

fn tup_field(self, index: usize) -> ExprBuilder<ExprTupFieldBuilder<F>>

fn box_(self) -> ExprBuilder<ExprPathBuilder<F>>

fn rc(self) -> ExprBuilder<ExprPathBuilder<F>>

fn arc(self) -> ExprBuilder<ExprPathBuilder<F>>

fn default(self) -> F::Result

fn slice(self) -> ExprSliceBuilder<F>

fn vec(self) -> ExprSliceBuilder<ExprVecBuilder<F>>

fn try(self) -> ExprBuilder<ExprTryBuilder<F>>[]

Represents an equivalent to try!(...).

Trait Implementations

impl<F> Invoke<Attribute> for ExprBuilder<F> where F: Invoke<P<Expr>>

type Result = Self

fn invoke(self, attr: Attribute) -> Self

impl<F> Invoke<P<Lit>> for ExprBuilder<F> where F: Invoke<P<Expr>>

type Result = F::Result

fn invoke(self, lit: P<Lit>) -> F::Result

impl<F> Invoke<Path> for ExprBuilder<F> where F: Invoke<P<Expr>>

type Result = F::Result

fn invoke(self, path: Path) -> F::Result

impl<F> Invoke<(QSelf, Path)> for ExprBuilder<F> where F: Invoke<P<Expr>>

type Result = F::Result

fn invoke(self, (qself, path): (QSelf, Path)) -> F::Result

impl<F> Invoke<P<Block>> for ExprBuilder<F> where F: Invoke<P<Expr>>

type Result = F::Result

fn invoke(self, block: P<Block>) -> F::Result