Struct ConstEvalCtxt

pub struct ConstEvalCtxt<'tcx> {
    tcx: TyCtxt<'tcx>,
    param_env: ParamEnv<'tcx>,
    typeck: &'tcx TypeckResults<'tcx>,
    source: Cell<ConstantSource>,
}

The context required to evaluate a constant expression.

This is currently limited to constant folding and reading the value of named constants.

Fields

tcx: TyCtxt<'tcx>

param_env: ParamEnv<'tcx>

typeck: &'tcx TypeckResults<'tcx>

source: Cell<ConstantSource>

Implementations

impl<'tcx> ConstEvalCtxt<'tcx>

pub fn new(cx: &LateContext<'tcx>) -> Self

Creates the evaluation context from the lint context. This requires the lint context to be in a body (i.e. cx.enclosing_body.is_some()).

pub fn with_env( tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx>, typeck: &'tcx TypeckResults<'tcx>, ) -> Self

Creates an evaluation context.

pub fn eval_with_source( &self, e: &Expr<'_>, ) -> Option<(Constant<'tcx>, ConstantSource)>

Attempts to evaluate the expression and returns both the value and whether it’s dependant on other items.

pub fn eval(&self, e: &Expr<'_>) -> Option<Constant<'tcx>>

Attempts to evaluate the expression.

pub fn eval_simple(&self, e: &Expr<'_>) -> Option<Constant<'tcx>>

Attempts to evaluate the expression without accessing other items.

pub fn eval_full_int(&self, e: &Expr<'_>) -> Option<FullInt>

Attempts to evaluate the expression as an integer without accessing other items.

fn expr(&self, e: &Expr<'_>) -> Option<Constant<'tcx>>

Simple constant folding: Insert an expression, get a constant or none.

pub fn eval_is_empty(&self, e: &Expr<'_>) -> Option<bool>

Simple constant folding to determine if an expression is an empty slice, str, array, … None will be returned if the constness cannot be determined, or if the resolution leaves the local crate.

fn constant_not(&self, o: &Constant<'tcx>, ty: Ty<'_>) -> Option<Constant<'tcx>>

fn constant_negate( &self, o: &Constant<'tcx>, ty: Ty<'_>, ) -> Option<Constant<'tcx>>

fn multi(&self, vec: &[Expr<'_>]) -> Option<Vec<Constant<'tcx>>>

Create Some(Vec![..]) of all constants, unless there is any non-constant part.

fn fetch_path_and_apply<T, F>( &self, qpath: &QPath<'_>, id: HirId, ty: Ty<'tcx>, f: F, ) -> Option<T>

where F: FnOnce(&Self, Const<'tcx>) -> Option<T>,

Lookup a possibly constant expression from an ExprKind::Path and apply a function on it.

fn index(&self, lhs: &Expr<'_>, index: &Expr<'_>) -> Option<Constant<'tcx>>

fn block(&self, block: &Block<'_>) -> Option<Constant<'tcx>>

A block can only yield a constant if it has exactly one constant expression.

fn ifthenelse( &self, cond: &Expr<'_>, then: &Expr<'_>, otherwise: Option<&Expr<'_>>, ) -> Option<Constant<'tcx>>

fn binop( &self, op: BinOp, left: &Expr<'_>, right: &Expr<'_>, ) -> Option<Constant<'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: 32 bytes