Struct rustc_mir_build::thir::cx::Cx

pub(crate) struct Cx<'a, 'tcx> {
    tcx: TyCtxt<'tcx>,
    infcx: &'a InferCtxt<'a, 'tcx>,
    pub(crate) root_lint_level: HirId,
    pub(crate) param_env: ParamEnv<'tcx>,
    pub(crate) identity_substs: &'tcx InternalSubsts<'tcx>,
    pub(crate) region_scope_tree: &'tcx ScopeTree,
    pub(crate) typeck_results: &'a TypeckResults<'tcx>,
    constness: Constness,
    body_owner: DefId,
    pub(crate) body_owner_kind: BodyOwnerKind,
    check_overflow: bool,
}

Fields

tcx: TyCtxt<'tcx>

infcx: &'a InferCtxt<'a, 'tcx>

root_lint_level: HirId

param_env: ParamEnv<'tcx>

identity_substs: &'tcx InternalSubsts<'tcx>

Identity InternalSubsts for use with const-evaluation.

region_scope_tree: &'tcx ScopeTree

typeck_results: &'a TypeckResults<'tcx>

constness: Constness

This is Constness::Const if we are compiling a static, const, or the body of a const fn.

body_owner: DefId

The DefId of the owner of this body.

body_owner_kind: BodyOwnerKind

What kind of body is being compiled.

check_overflow: bool

Whether this constant/function needs overflow checks.

Implementations

impl<'a, 'tcx> Cx<'a, 'tcx>

pub(crate) fn new(
    infcx: &'a InferCtxt<'a, 'tcx>,
    def: WithOptConstParam<LocalDefId>,
    src_id: HirId
) -> Cx<'a, 'tcx>

impl<'a, 'tcx> Cx<'a, 'tcx>

pub(crate) fn mirror<M: Mirror<'tcx>>(&mut self, ast: M) -> M::Output

Normalizes ast into the appropriate "mirror" type.

pub(crate) fn usize_ty(&mut self) -> Ty<'tcx>

pub(crate) fn usize_literal(&mut self, value: u64) -> &'tcx Const<'tcx>

pub(crate) fn bool_ty(&mut self) -> Ty<'tcx>

pub(crate) fn unit_ty(&mut self) -> Ty<'tcx>

pub(crate) fn true_literal(&mut self) -> &'tcx Const<'tcx>

pub(crate) fn false_literal(&mut self) -> &'tcx Const<'tcx>

pub(crate) fn const_eval_literal(
    &mut self,
    lit: &'tcx LitKind,
    ty: Ty<'tcx>,
    sp: Span,
    neg: bool
) -> &'tcx Const<'tcx>

pub(crate) fn pattern_from_hir(&mut self, p: &Pat<'_>) -> Pat<'tcx>

pub(crate) fn trait_method(
    &mut self,
    trait_def_id: DefId,
    method_name: Symbol,
    self_ty: Ty<'tcx>,
    params: &[GenericArg<'tcx>]
) -> &'tcx Const<'tcx>

pub(crate) fn all_fields(
    &mut self,
    adt_def: &AdtDef,
    variant_index: VariantIdx
) -> Vec<Field>

pub(crate) fn needs_drop(&mut self, ty: Ty<'tcx>) -> bool

pub(crate) fn infcx(&self) -> &'a InferCtxt<'a, 'tcx>

pub(crate) fn tcx(&self) -> TyCtxt<'tcx>

pub(crate) fn typeck_results(&self) -> &'a TypeckResults<'tcx>

pub(crate) fn check_overflow(&self) -> bool

pub(crate) fn type_is_copy_modulo_regions(
    &self,
    ty: Ty<'tcx>,
    span: Span
) -> bool

Trait Implementations

impl<'a, 'tcx> Clone for Cx<'a, 'tcx>

pub fn clone(&self) -> Cx<'a, 'tcx>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx, '_> UserAnnotatedTyHelpers<'tcx> for Cx<'_, 'tcx>

pub(crate) fn tcx(&self) -> TyCtxt<'tcx>

pub(crate) fn typeck_results(&self) -> &TypeckResults<'tcx>

pub(crate) fn user_substs_applied_to_ty_of_hir_id(
    &self,
    hir_id: HirId
) -> Option<CanonicalUserType<'tcx>>

Looks up the type associated with this hir-id and applies the user-given substitutions; the hir-id must map to a suitable type.