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 new_with_callback(callback: F) -> Self`

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

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

`fn build_expr_(self, expr: Expr_) -> 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 int(self, value: i64) -> 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 str<S>(self, value: S) -> F::Result where S: ToInternedString`

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

`fn build_box(self, 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: BinOp_, 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: BinOp_) -> 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 addr_of(self) -> ExprBuilder<ExprAddrOfBuilder<F>>`

`fn mut_addr_of(self) -> ExprBuilder<ExprAddrOfBuilder<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_(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 block(self) -> BlockBuilder<Self>`

`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 slice(self) -> ExprSliceBuilder<F>`

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

Trait Implementations

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