Struct Expr

pub struct Expr<'tcx> {
    pub kind: ExprKind,
    args: GenericArgsRef<'tcx>,
}

Fields

kind: ExprKind

args: GenericArgsRef<'tcx>

Implementations

impl<'tcx> Expr<'tcx>

pub fn new_binop( tcx: TyCtxt<'tcx>, binop: BinOp, lhs_ty: Ty<'tcx>, rhs_ty: Ty<'tcx>, lhs_ct: Const<'tcx>, rhs_ct: Const<'tcx>, ) -> Self

pub fn binop_args(self) -> (Ty<'tcx>, Ty<'tcx>, Const<'tcx>, Const<'tcx>)

pub fn new_unop( tcx: TyCtxt<'tcx>, unop: UnOp, ty: Ty<'tcx>, ct: Const<'tcx>, ) -> Self

pub fn unop_args(self) -> (Ty<'tcx>, Const<'tcx>)

pub fn new_call( tcx: TyCtxt<'tcx>, func_ty: Ty<'tcx>, func_expr: Const<'tcx>, arguments: impl IntoIterator<Item = Const<'tcx>>, ) -> Self

pub fn call_args( self, ) -> (Ty<'tcx>, Const<'tcx>, impl Iterator<Item = Const<'tcx>>)

pub fn new_cast( tcx: TyCtxt<'tcx>, cast: CastKind, value_ty: Ty<'tcx>, value: Const<'tcx>, to_ty: Ty<'tcx>, ) -> Self

pub fn cast_args(self) -> (Ty<'tcx>, Const<'tcx>, Ty<'tcx>)

pub fn new(kind: ExprKind, args: GenericArgsRef<'tcx>) -> Self

pub fn args(self) -> GenericArgsRef<'tcx>

Trait Implementations

impl<'tcx> Clone for Expr<'tcx>

fn clone(&self) -> Expr<'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for Expr<'tcx>

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

Formats the value using the given formatter.

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for Expr<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for Expr<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx> ExprConst<TyCtxt<'tcx>> for Expr<'tcx>

fn args(self) -> GenericArgsRef<'tcx>

impl<'tcx> Hash for Expr<'tcx>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for Expr<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher, )

impl<'tcx> PartialEq for Expr<'tcx>

fn eq(&self, other: &Expr<'tcx>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'tcx> Relate<TyCtxt<'tcx>> for Expr<'tcx>

fn relate<R: TypeRelation<TyCtxt<'tcx>>>( relation: &mut R, ae: Expr<'tcx>, be: Expr<'tcx>, ) -> RelateResult<'tcx, Expr<'tcx>>

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for Expr<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F, ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for Expr<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V, ) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'tcx> Copy for Expr<'tcx>

impl<'tcx> Eq for Expr<'tcx>

impl<'tcx> StructuralPartialEq for Expr<'tcx>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes