Struct TyCtxtFeed

pub struct TyCtxtFeed<'tcx, KEY: Copy> {
    pub tcx: TyCtxt<'tcx>,
    key: KEY,
}

This struct should only be created by create_def.

Fields

tcx: TyCtxt<'tcx>

key: KEY

Implementations

impl<'tcx, KEY: Copy> TyCtxtFeed<'tcx, KEY>

pub fn key(&self) -> KEY

pub fn downgrade(self) -> Feed<'tcx, KEY>

impl<'tcx> TyCtxtFeed<'tcx, LocalDefId>

pub fn def_id(&self) -> LocalDefId

pub fn feed_owner_id(&self) -> TyCtxtFeed<'tcx, OwnerId>

pub fn feed_hir(&self)

impl<'tcx, K: IntoQueryParam<LocalDefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn local_def_id_to_hir_id(self, value: ProvidedValue<'tcx>)

Returns HIR ID for the given LocalDefId.

impl<'tcx, K: IntoQueryParam<LocalDefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn opt_hir_owner_nodes(self, value: ProvidedValue<'tcx>)

Gives access to the HIR nodes and bodies inside key if it’s a HIR owner.

This can be conveniently accessed by methods on tcx.hir(). Avoid calling this query directly.

impl<'tcx, K: IntoQueryParam<OwnerId> + Copy> TyCtxtFeed<'tcx, K>

pub fn hir_attr_map(self, value: ProvidedValue<'tcx>)

Gives access to the HIR attributes inside the HIR owner key.

This can be conveniently accessed by methods on tcx.hir(). Avoid calling this query directly.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn type_of(self, value: ProvidedValue<'tcx>)

Returns the type of the definition given by DefId.

For type aliases (whether eager or lazy) and associated types, this returns the underlying aliased type (not the corresponding alias type).

For opaque types, this returns and thus reveals the hidden type! If you want to detect cycle errors use type_of_opaque instead.

To clarify, for type definitions, this does not return the “type of a type” (aka kind or sort) in the type-theoretical sense! It merely returns the type primarily associated with it.

Panics

This query will panic if the given definition doesn’t (and can’t conceptually) have an (underlying) type.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn generics_of(self, value: ProvidedValue<'tcx>)

Returns the generics of the definition given by DefId.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn predicates_of(self, value: ProvidedValue<'tcx>)

Returns the (elaborated) predicates of the definition given by DefId that must be proven true at usage sites (and which can be assumed at definition site).

This is almost always the “predicates query” that you want.

Tip: You can use #[rustc_dump_predicates] on an item to basically print the result of this query for use in UI tests or for debugging purposes.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn explicit_item_bounds(self, value: ProvidedValue<'tcx>)

Returns the explicitly user-written bounds on the associated or opaque type given by DefId that must be proven true at definition site (and which can be assumed at usage sites).

For associated types, these must be satisfied for an implementation to be well-formed, and for opaque types, these are required to be satisfied by the hidden type of the opaque.

Bounds from the parent (e.g. with nested impl Trait) are not included.

Syntactially, these are the bounds written on associated types in trait definitions, or those after the impl keyword for an opaque:

trait Trait { type X: Bound + 'lt; }
//                    ^^^^^^^^^^^
fn function() -> impl Debug + Display { /*...*/ }
//                    ^^^^^^^^^^^^^^^

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn explicit_item_self_bounds(self, value: ProvidedValue<'tcx>)

Returns the explicitly user-written bounds that share the Self type of the item.

These are a subset of the explicit item bounds that may explicitly be used for things like closure signature deduction.

impl<'tcx, K: IntoQueryParam<LocalDefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn mir_built(self, value: ProvidedValue<'tcx>)

Build the MIR for a given DefId and prepare it for const qualification.

See the rustc dev guide for more info.

impl<'tcx, K: IntoQueryParam<LocalDefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn coverage_attr_on(self, value: ProvidedValue<'tcx>)

Checks for the nearest #[coverage(off)] or #[coverage(on)] on this def and any enclosing defs, up to the crate root.

Returns false if #[coverage(off)] was found, or true if either #[coverage(on)] or no coverage attribute was found.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn explicit_predicates_of(self, value: ProvidedValue<'tcx>)

Returns the explicitly user-written predicates of the definition given by DefId that must be proven true at usage sites (and which can be assumed at definition site).

You should probably use Self::predicates_of unless you’re looking for predicates with explicit spans for diagnostics purposes.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn inferred_outlives_of(self, value: ProvidedValue<'tcx>)

Returns the inferred outlives-predicates of the item given by DefId.

E.g., for struct Foo<'a, T> { x: &'a T }, this would return [T: 'a].

Tip: You can use #[rustc_outlives] on an item to basically print the result of this query for use in UI tests or for debugging purposes.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn constness(self, value: ProvidedValue<'tcx>)

Returns the constness of the function-like¹ definition given by DefId.

Tuple struct/variant constructors are always const, foreign functions are never const. The rest is const iff marked with keyword const (or rather its parent in the case of associated functions).

Do not call this query directly. It is only meant to cache the base data for the higher-level functions. Consider using is_const_fn or is_const_trait_impl instead.

Also note that neither of them takes into account feature gates, stability and const predicates/conditions!

Panics

This query will panic if the given definition is not function-like¹.

---

1. Tuple struct/variant constructors, closures and free, associated and foreign functions. ↩

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn coroutine_kind(self, value: ProvidedValue<'tcx>)

Returns Some(coroutine_kind) if the node pointed to by def_id is a coroutine.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn associated_item(self, value: ProvidedValue<'tcx>)

Maps from a trait/impl item to the trait/impl item “descriptor”.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn eval_static_initializer(self, value: ProvidedValue<'tcx>)

Evaluate a static’s initializer, returning the allocation of the initializer’s memory.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn def_kind(self, value: ProvidedValue<'tcx>)

[query description - consider adding a doc-comment!] looking up definition kind of tcx.def_path_str(def_id)

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn def_span(self, value: ProvidedValue<'tcx>)

Gets the span for the definition.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn def_ident_span(self, value: ProvidedValue<'tcx>)

Gets the span for the identifier of the definition.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn codegen_fn_attrs(self, value: ProvidedValue<'tcx>)

[query description - consider adding a doc-comment!] computing codegen attributes of tcx.def_path_str(def_id)

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn param_env(self, value: ProvidedValue<'tcx>)

Gets the ParameterEnvironment for a given item; this environment will be in “user-facing” mode, meaning that it is suitable for type-checking etc, and it does not normalize specializable associated types.

You should almost certainly not use this. If you already have an InferCtxt, then you should also probably have a ParamEnv from when it was built. If you don’t, then you should take a TypingEnv to ensure that you handle opaque types correctly.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn defaultness(self, value: ProvidedValue<'tcx>)

Returns whether the impl or associated function has the default keyword.

impl<'tcx, K: IntoQueryParam<DefId> + Copy> TyCtxtFeed<'tcx, K>

pub fn visibility(self, value: ProvidedValue<'tcx>)

Computes the visibility of the provided def_id.

If the item from the def_id doesn’t have a visibility, it will panic. For example a generic type parameter will panic if you call this method on it:

use std::fmt::Debug;

pub trait Foo<T: Debug> {}

In here, if you call visibility on T, it’ll panic.

impl<'tcx, K: IntoQueryParam<CrateNum> + Copy> TyCtxtFeed<'tcx, K>

pub fn crate_name(self, value: ProvidedValue<'tcx>)

Gets the name of the crate.

impl<'tcx, K: IntoQueryParam<()> + Copy> TyCtxtFeed<'tcx, K>

pub fn output_filenames(self, value: ProvidedValue<'tcx>)

Return the filenames where output artefacts shall be stored.

This query returns an &Arc because codegen backends need the value even after the TyCtxt has been destroyed.

impl<'tcx, K: IntoQueryParam<()> + Copy> TyCtxtFeed<'tcx, K>

pub fn features_query(self, value: ProvidedValue<'tcx>)

[query description - consider adding a doc-comment!] looking up enabled feature gates

impl<'tcx, K: IntoQueryParam<()> + Copy> TyCtxtFeed<'tcx, K>

pub fn crate_for_resolver(self, value: ProvidedValue<'tcx>)

[query description - consider adding a doc-comment!] the ast before macro expansion and name resolution

Trait Implementations

impl<'tcx, KEY: Clone + Copy> Clone for TyCtxtFeed<'tcx, KEY>

fn clone(&self) -> TyCtxtFeed<'tcx, KEY>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx, KEY: Copy + Copy> Copy for TyCtxtFeed<'tcx, KEY>

impl<KEY: Copy, CTX> !HashStable<CTX> for TyCtxtFeed<'_, KEY>

Never return a Feed from a query. Only queries that create a DefId are allowed to feed queries for that DefId.

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.