DepKindVTable in rustc_middle::dep_graph::dep_node - Rust
Description: This struct stores function pointers and other metadata for a particular DepKind.

Skip to main content

## DepKindVTable

# Struct DepKindVTable

Source

    pub struct DepKindVTable<'tcx> {
        pub is_eval_always: bool,
        pub key_fingerprint_style: KeyFingerprintStyle,
        pub force_from_dep_node_fn: Option<fn(tcx: TyCtxt<'tcx>, dep_node: DepNode, prev_index: SerializedDepNodeIndex) -> bool>,
        pub promote_from_disk_fn: Option<fn(TyCtxt<'tcx>, DepNode)>,
    }

Expand description

This struct stores function pointers and other metadata for a particular DepKind.

Information is retrieved by indexing the `DEP_KINDS` array using the integer value of the `DepKind`. Overall, this allows to implement `DepContext` using this manual jump table instead of large matches.

## Fields§

§`is_eval_always: bool`

Eval-always queries do not track their dependencies, and are always recomputed, even if their inputs have not changed since the last compiler invocation. The result is still cached within one compiler invocation.

§`key_fingerprint_style: KeyFingerprintStyle`

Indicates whether and how a query key can be reconstructed from the key fingerprint of a dep node with this `DepKind`.

The `DepNodeKey` trait determines the fingerprint style for each key type.

§`force_from_dep_node_fn: Option<fn(tcx: TyCtxt<'tcx>, dep_node: DepNode, prev_index: SerializedDepNodeIndex) -> bool>`

The red/green evaluation system will try to mark a specific DepNode in the dependency graph as green by recursively trying to mark the dependencies of that `DepNode` as green. While doing so, it will sometimes encounter a `DepNode` where we don’t know if it is red or green and we therefore actually have to recompute its value in order to find out. Since the only piece of information that we have at that point is the `DepNode` we are trying to re-evaluate, we need some way to re-run a query from just that. This is what `force_from_dep_node()` implements.

In the general case, a `DepNode` consists of a `DepKind` and an opaque “key fingerprint” that will uniquely identify the node. This key fingerprint is usually constructed by computing a stable hash of the query-key that the `DepNode` corresponds to. Consequently, it is not in general possible to go back from hash to query-key (since hash functions are not reversible). For this reason `force_from_dep_node()` is expected to fail from time to time because we just cannot find out, from the `DepNode` alone, what the corresponding query-key is and therefore cannot re-run the query.

The system deals with this case letting `try_mark_green` fail which forces the root query to be re-evaluated.

Now, if `force_from_dep_node()` would always fail, it would be pretty useless. Fortunately, we can use some contextual information that will allow us to reconstruct query-keys for certain kinds of `DepNode`s. In particular, we enforce by construction that the key fingerprint of certain `DepNode`s is a valid `DefPathHash`. Since we also always build a huge table that maps every `DefPathHash` in the current codebase to the corresponding `DefId`, we have everything we need to re-run the query.

Take the `mir_promoted` query as an example. Like many other queries, it just has a single parameter: the `DefId` of the item it will compute the validated MIR for. Now, when we call `force_from_dep_node()` on a `DepNode` with kind `mir_promoted`, we know that the key fingerprint of the `DepNode` is actually a `DefPathHash`, and can therefore just look up the corresponding `DefId` in `tcx.def_path_hash_to_def_id`.

§`promote_from_disk_fn: Option<fn(TyCtxt<'tcx>, DepNode)>`

Invoke a query to put the on-disk cached value in memory.

## Trait Implementations§

Source§

### impl<'tcx> ArenaAllocatable<'tcx> for DepKindVTable<'tcx>

Source§

#### fn allocate_on(self, arena: &'tcx Arena<'tcx>) -> &'tcx mut Self

Source§

#### fn allocate_from_iter( arena: &'tcx Arena<'tcx>, iter: impl IntoIterator<Item = Self>, ) -> &'tcx mut [Self]

## Auto Trait Implementations§

§

### impl<'tcx> DynSend for DepKindVTable<'tcx>

§

### impl<'tcx> DynSync for DepKindVTable<'tcx>

§

### impl<'tcx> Freeze for DepKindVTable<'tcx>

§

### impl<'tcx> RefUnwindSafe for DepKindVTable<'tcx>

§

### impl<'tcx> Send for DepKindVTable<'tcx>

§

### impl<'tcx> Sync for DepKindVTable<'tcx>

§

### impl<'tcx> Unpin for DepKindVTable<'tcx>

§

### impl<'tcx> UnsafeUnpin for DepKindVTable<'tcx>

§

### impl<'tcx> UnwindSafe for DepKindVTable<'tcx>

## Blanket Implementations§

Source§

### impl<T> Aligned for T

Source§

#### const ALIGN: Alignment

Alignment of `Self`.
Source§

### impl<T> Any for T
where T: 'static + ?Sized,

Source§

#### fn type_id(&self) -> TypeId

Gets the `TypeId` of `self`. Read more
Source§

### impl<T> Borrow<T> for T
where T: ?Sized,

Source§

#### fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

### impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

#### fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

### impl<T, R> CollectAndApply<T, R> for T

Source§

#### fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

Equivalent to `f(&iter.collect::<Vec<_>>())`.

Source§

#### type Output = R

Source§

### impl<T> From<T> for T

Source§

#### fn from(t: T) -> T

Returns the argument unchanged.

Source§

### impl<T> Instrument for T

Source§

#### fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided `Span`, returning an `Instrumented` wrapper. Read more
Source§

#### fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current `Span`, returning an `Instrumented` wrapper. Read more
Source§

### impl<T, U> Into<U> for T
where U: From<T>,

Source§

#### fn into(self) -> U

Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.

Source§

### impl<T> IntoEither for T

Source§

#### fn into_either(self, into_left: bool) -> Either<Self, Self>

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left` is `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

Converts `self` into a `Left` variant of `Either<Self, Self>` if `into_left(&self)` returns `true`. Converts `self` into a `Right` variant of `Either<Self, Self>` otherwise. Read more
Source§

### impl<K> IntoQueryKey<K> for K

Source§

#### fn into_query_key(self) -> K

Argument conversion from `Self` to `K`. This should always be a very cheap conversion, e.g. `LocalDefId::to_def_id`.
Source§

### impl<T> MaybeResult<T> for T

Source§

#### type Error = !

Source§

#### fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

Source§

#### fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

Source§

### impl<T> Pointable for T

Source§

#### const ALIGN: usize

The alignment of pointer.
Source§

#### type Init = T

The type for initializers.
Source§

#### unsafe fn init(init: <T as Pointable>::Init) -> usize

Initializes a with the given initializer. Read more
Source§

#### unsafe fn deref<'a>(ptr: usize) -> &'a T

Dereferences the given pointer. Read more
Source§

#### unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

Mutably dereferences the given pointer. Read more
Source§

#### unsafe fn drop(ptr: usize)

Drops the object pointed to by the given pointer. Read more
Source§

### impl<T> Same for T

Source§

#### type Output = T

Should always be `Self`
Source§

### impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

#### type Error = Infallible

The type returned in the event of a conversion error.
Source§

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

### impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.
Source§

### impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

Source§

#### fn upcast(self, interner: I) -> U

Source§

### impl<I, T> UpcastFrom<I, T> for T

Source§

#### fn upcast_from(from: T, _tcx: I) -> T

Source§

### impl<V, T> VZip<V> for T
where V: MultiLane<T>,

Source§

#### fn vzip(self) -> V

Source§

### impl<T> WithSubscriber for T

Source§

#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§

#### fn with_current_subscriber(self) -> WithDispatch<Self>

Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper. Read more
Source§

### impl<T> ErasedDestructor for T
where T: 'static,

## 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: 24 bytes