Struct SmirCtxt

pub struct SmirCtxt<'tcx, B: Bridge> {
    pub tcx: TyCtxt<'tcx>,
    _marker: PhantomData<B>,
}

Provides direct access to rustc’s internal queries.

SmirInterface must go through this context to obtain rustc-level information.

Fields

tcx: TyCtxt<'tcx>

_marker: PhantomData<B>

Implementations

impl<'tcx, B: Bridge> SmirCtxt<'tcx, B>

pub fn lift<T: Lift<TyCtxt<'tcx>>>(&self, value: T) -> Option<T::Lifted>

pub fn adt_def(&self, def_id: DefId) -> AdtDef<'tcx>

pub fn coroutine_movability(&self, def_id: DefId) -> Movability

pub fn valtree_to_const_val(&self, key: Value<'tcx>) -> ConstValue<'tcx>

pub(crate) fn instance_has_body(&self, instance: Instance<'tcx>) -> bool

Return whether the instance as a body available.

Items and intrinsics may have a body available from its definition. Shims body may be generated depending on their type.

pub(crate) fn item_has_body(&self, def_id: DefId) -> bool

Return whether the item has a body defined by the user.

Note that intrinsics may have a placeholder body that shouldn’t be used in practice. In StableMIR, we handle this case as if the body is not available.

fn filter_fn_def(&self, def_id: DefId) -> Option<DefId>

fn filter_static_def(&self, def_id: DefId) -> Option<DefId>

pub fn target_endian(&self) -> Endian

pub fn target_pointer_size(&self) -> usize

pub fn entry_fn(&self) -> Option<DefId>

pub fn all_local_items(&self) -> Vec<DefId>

Retrieve all items of the local crate that have a MIR associated with them.

pub fn mir_body(&self, item: DefId) -> &'tcx Body<'tcx>

Retrieve the body of a function. This function will panic if the body is not available.

pub fn has_body(&self, def: DefId) -> bool

Check whether the body of a function is available.

pub fn foreign_modules(&self, crate_num: CrateNum) -> Vec<DefId>

pub fn crate_functions(&self, crate_num: CrateNum) -> Vec<DefId>

Retrieve all functions defined in this crate.

pub fn crate_statics(&self, crate_num: CrateNum) -> Vec<DefId>

Retrieve all static items defined in this crate.

pub fn foreign_module(&self, mod_def: DefId) -> &ForeignModule

pub fn foreign_items(&self, mod_def: DefId) -> Vec<DefId>

pub fn all_trait_decls(&self) -> impl Iterator<Item = DefId>

pub fn trait_decls(&self, crate_num: CrateNum) -> Vec<DefId>

pub fn trait_decl(&self, trait_def: DefId) -> &'tcx TraitDef

pub fn all_trait_impls(&self) -> Vec<DefId>

pub fn trait_impls(&self, crate_num: CrateNum) -> Vec<DefId>

pub fn trait_impl(&self, impl_def: DefId) -> EarlyBinder<'tcx, TraitRef<'tcx>>

pub fn generics_of(&self, def_id: DefId) -> &'tcx Generics

pub fn predicates_of( &self, def_id: DefId, ) -> (Option<DefId>, Vec<(PredicateKind<'tcx>, Span)>)

pub fn explicit_predicates_of( &self, def_id: DefId, ) -> (Option<DefId>, Vec<(PredicateKind<'tcx>, Span)>)

pub fn crate_name(&self, crate_num: CrateNum) -> String

pub fn crate_is_local(&self, crate_num: CrateNum) -> bool

pub fn crate_num_id(&self, crate_num: CrateNum) -> usize

pub fn local_crate_num(&self) -> CrateNum

pub fn external_crates(&self) -> Vec<CrateNum>

Retrieve a list of all external crates.

pub fn find_crates(&self, name: &str) -> Vec<CrateNum>

Find a crate with the given name.

pub fn def_name(&self, def_id: DefId, trimmed: bool) -> String

Returns the name of given DefId.

pub fn tool_attrs(&self, def_id: DefId, attr: &[String]) -> Vec<(String, Span)>

Return registered tool attributes with the given attribute name.

FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool attributes will simply return an empty list.

Single segmented name like #[clippy] is specified as &["clippy".to_string()]. Multi-segmented name like #[rustfmt::skip] is specified as &["rustfmt".to_string(), "skip".to_string()].

pub fn all_tool_attrs(&self, did: DefId) -> Vec<(String, Span)>

Get all tool attributes of a definition.

pub fn span_to_string(&self, span: Span) -> String

Returns printable, human readable form of Span.

pub fn get_filename(&self, span: Span) -> String

Return filename from given Span, for diagnostic purposes.

pub fn get_lines(&self, span: Span) -> (usize, usize, usize, usize)

Return lines corresponding to this Span.

pub fn def_kind(&self, item: DefId) -> DefKind

Returns the kind of given DefId.

pub fn is_foreign_item(&self, item: DefId) -> bool

Returns whether this is a foreign item.

pub fn foreign_item_kind(&self, def_id: DefId) -> DefKind

Returns the kind of a given foreign item.

pub fn adt_kind(&self, def: AdtDef<'tcx>) -> AdtKind

Returns the kind of a given algebraic data type.

pub fn adt_is_box(&self, def: AdtDef<'tcx>) -> bool

Returns if the ADT is a box.

pub fn adt_is_simd(&self, def: AdtDef<'tcx>) -> bool

Returns whether this ADT is simd.

pub fn adt_is_cstr(&self, def_id: DefId) -> bool

Returns whether this definition is a C string.

pub fn adt_repr(&self, def: AdtDef<'tcx>) -> ReprOptions

Returns the representation options for this ADT.

pub fn fn_sig( &self, def_id: DefId, args_ref: GenericArgsRef<'tcx>, ) -> Binder<'tcx, FnSig<'tcx>>

Retrieve the function signature for the given generic arguments.

pub fn intrinsic(&self, def_id: DefId) -> Option<IntrinsicDef>

Retrieve the intrinsic definition if the item corresponds one.

pub fn intrinsic_name(&self, def_id: DefId) -> String

Retrieve the plain function name of an intrinsic.

pub fn closure_sig( &self, args_ref: GenericArgsRef<'tcx>, ) -> Binder<'tcx, FnSig<'tcx>>

Retrieve the closure signature for the given generic arguments.

pub fn adt_variants_len(&self, def: AdtDef<'tcx>) -> usize

The number of variants in this ADT.

pub fn adt_discr_for_variant( &self, adt: AdtDef<'tcx>, variant: VariantIdx, ) -> Discr<'tcx>

Discriminant for a given variant index of AdtDef.

pub fn coroutine_discr_for_variant( &self, coroutine: DefId, args: GenericArgsRef<'tcx>, variant: VariantIdx, ) -> Discr<'tcx>

Discriminant for a given variand index and args of a coroutine.

pub fn variant_name(&self, def: &'tcx VariantDef) -> String

The name of a variant.

pub fn eval_target_usize(&self, cnst: MirConst<'tcx>) -> Result<u64, B::Error>

Evaluate constant as a target usize.

pub fn eval_target_usize_ty(&self, cnst: Const<'tcx>) -> Result<u64, B::Error>

pub fn try_new_const_zst( &self, ty_internal: Ty<'tcx>, ) -> Result<MirConst<'tcx>, B::Error>

pub fn const_zero_sized(&self, ty_internal: Ty<'tcx>) -> Const<'tcx>

pub fn new_const_str(&self, value: &str) -> MirConst<'tcx>

Create a new constant that represents the given string value.

pub fn new_const_bool(&self, value: bool) -> MirConst<'tcx>

Create a new constant that represents the given boolean value.

pub fn try_new_const_uint( &self, value: u128, ty_internal: Ty<'tcx>, ) -> Result<MirConst<'tcx>, B::Error>

pub fn try_new_ty_const_uint( &self, value: u128, ty_internal: Ty<'tcx>, ) -> Result<Const<'tcx>, B::Error>

pub fn ty_new_uint(&self, ty: UintTy) -> Ty<'tcx>

pub fn mir_const_from_scalar(&self, s: Scalar, ty: Ty<'tcx>) -> MirConst<'tcx>

pub fn ty_const_new_value( &self, valtree: ValTree<'tcx>, ty: Ty<'tcx>, ) -> Const<'tcx>

pub fn ty_valtree_from_scalar_int(&self, i: ScalarInt) -> ValTree<'tcx>

pub fn new_rigid_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx>

Create a new type from the given kind.

pub fn new_box_ty(&self, ty: Ty<'tcx>) -> Ty<'tcx>

Create a new box type, Box<T>, for the given inner type T.

pub fn def_ty(&self, item: DefId) -> Ty<'tcx>

Returns the type of given crate item.

pub fn def_ty_with_args( &self, item: DefId, args_ref: GenericArgsRef<'tcx>, ) -> Ty<'tcx>

Returns the type of given definition instantiated with the given arguments.

pub fn span_of_an_item(&self, def_id: DefId) -> Span

Span of an item.

pub fn ty_const_pretty(&self, ct: Const<'tcx>) -> String

pub fn ty_pretty(&self, ty: Ty<'tcx>) -> String

Obtain the representation of a type.

pub fn ty_kind(&self, ty: Ty<'tcx>) -> &'tcx TyKind<'tcx>

Obtain the kind of a type.

pub fn rigid_ty_discriminant_ty(&self, internal_kind: TyKind<'tcx>) -> Ty<'tcx>

Get the discriminant Ty for this Ty if there’s one.

pub fn instance_body(&self, instance: Instance<'tcx>) -> Option<Body<'tcx>>

Get the body of an Instance which is already monomorphized.

pub fn instance_ty(&self, instance: Instance<'tcx>) -> Ty<'tcx>

Get the instance type with generic instantiations applied and lifetimes erased.

pub fn instance_args(&self, instance: Instance<'tcx>) -> GenericArgsRef<'tcx>

Get the instantiation types.

pub fn instance_abi( &self, instance: Instance<'tcx>, ) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error>

Get an instance ABI.

pub fn fn_ptr_abi( &self, sig: PolyFnSig<'tcx>, ) -> Result<&FnAbi<'tcx, Ty<'tcx>>, B::Error>

Get the ABI of a function pointer.

pub fn instance_def_id( &self, instances: Instance<'tcx>, tables: &mut Tables<'_, B>, ) -> B::DefId

Get the instance.

pub fn instance_mangled_name(&self, instance: Instance<'tcx>) -> String

Get the instance mangled name.

pub fn is_empty_drop_shim(&self, instance: Instance<'tcx>) -> bool

Check if this is an empty DropGlue shim.

pub fn mono_instance(&self, def_id: DefId) -> Instance<'tcx>

Convert a non-generic crate item into an instance. This function will panic if the item is generic.

pub fn requires_monomorphization(&self, def_id: DefId) -> bool

Item requires monomorphization.

pub fn resolve_instance( &self, def_id: DefId, args_ref: GenericArgsRef<'tcx>, ) -> Option<Instance<'tcx>>

Resolve an instance from the given function definition and generic arguments.

pub fn resolve_drop_in_place(&self, internal_ty: Ty<'tcx>) -> Instance<'tcx>

Resolve an instance for drop_in_place for the given type.

pub fn resolve_for_fn_ptr( &self, def_id: DefId, args_ref: GenericArgsRef<'tcx>, ) -> Option<Instance<'tcx>>

Resolve instance for a function pointer.

pub fn resolve_closure( &self, def_id: DefId, args_ref: GenericArgsRef<'tcx>, closure_kind: ClosureKind, ) -> Option<Instance<'tcx>>

Resolve instance for a closure with the requested type.

pub fn eval_instance( &self, instance: Instance<'tcx>, ) -> Result<ConstValue<'tcx>, ErrorHandled>

Try to evaluate an instance into a constant.

pub fn eval_static_initializer( &self, def_id: DefId, ) -> Result<ConstAllocation<'tcx>, ErrorHandled>

Evaluate a static’s initializer.

pub fn global_alloc(&self, alloc_id: AllocId) -> GlobalAlloc<'tcx>

Retrieve global allocation for the given allocation ID.

pub fn vtable_allocation( &self, ty: Ty<'tcx>, trait_ref: Option<Binder<'tcx, ExistentialTraitRef<'tcx>>>, ) -> AllocId

Retrieve the id for the virtual table.

pub fn instance_name(&self, instance: Instance<'tcx>, trimmed: bool) -> String

Retrieve the instance name for diagnostic messages.

This will return the specialized name, e.g., Vec<char>::new.

pub fn ty_layout(&self, ty: Ty<'tcx>) -> Result<Layout<'tcx>, B::Error>

Get the layout of a type.

pub fn binop_ty(&self, bin_op: BinOp, rhs: Ty<'tcx>, lhs: Ty<'tcx>) -> Ty<'tcx>

Get the resulting type of binary operation.

pub fn unop_ty(&self, un_op: UnOp, arg: Ty<'tcx>) -> Ty<'tcx>

Get the resulting type of unary operation.

pub fn associated_items(&self, def_id: DefId) -> Vec<AssocItem>

Get all associated items of a definition.

impl<'tcx, B: Bridge> SmirCtxt<'tcx, B>

pub fn new(tcx: TyCtxt<'tcx>) -> Self

Trait Implementations

impl<'tcx, B: Bridge> FnAbiOfHelpers<'tcx> for SmirCtxt<'tcx, B>

Implement error handling for extracting function ABI information.

type FnAbiOfResult = Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, <B as Bridge>::Error>

The &FnAbi-wrapping type (or &FnAbi itself), which will be returned from fn_abi_of_* (see also handle_fn_abi_err).

fn handle_fn_abi_err( &self, err: FnAbiError<'tcx>, _span: Span, fn_abi_request: FnAbiRequest<'tcx>, ) -> B::Error

Helper used for fn_abi_of_*, to adapt tcx.fn_abi_of_*(...) into a Self::FnAbiOfResult (which does not need to be a Result<...>).

impl<'tcx, B: Bridge> HasDataLayout for SmirCtxt<'tcx, B>

fn data_layout(&self) -> &TargetDataLayout

impl<'tcx, B: Bridge> HasTyCtxt<'tcx> for SmirCtxt<'tcx, B>

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

impl<'tcx, B: Bridge> HasTypingEnv<'tcx> for SmirCtxt<'tcx, B>

fn typing_env(&self) -> TypingEnv<'tcx>

fn param_env(&self) -> ParamEnv<'tcx>

FIXME(#132279): This method should not be used as in the future everything should take a TypingEnv instead. Remove it as that point.

impl<'tcx, B: Bridge> LayoutOfHelpers<'tcx> for SmirCtxt<'tcx, B>

type LayoutOfResult = Result<TyAndLayout<'tcx, Ty<'tcx>>, <B as Bridge>::Error>

The TyAndLayout-wrapping type (or TyAndLayout itself), which will be returned from layout_of (see also handle_layout_err).

fn handle_layout_err( &self, err: LayoutError<'tcx>, _span: Span, ty: Ty<'tcx>, ) -> B::Error

Helper used for layout_of, to adapt tcx.layout_of(...) into a Self::LayoutOfResult (which does not need to be a Result<...>).

fn layout_tcx_at_span(&self) -> Span

Span to use for tcx.at(span), from layout_of.

impl<'tcx, B: Bridge> SmirAllocRange<'tcx> for SmirCtxt<'tcx, B>

fn alloc_range(&self, offset: Size, size: Size) -> AllocRange

impl<'tcx, B: Bridge> SmirTy<'tcx> for SmirCtxt<'tcx, B>

fn new_foreign(&self, def_id: DefId) -> Ty<'tcx>

impl<'tcx, B: Bridge> SmirTypingEnv<'tcx> for SmirCtxt<'tcx, B>

fn fully_monomorphized(&self) -> TypingEnv<'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: 8 bytes