## CrateMetadataRef

# Struct CrateMetadataRef

Source

    pub(crate) struct CrateMetadataRef<'a> {
        pub cdata: &'a CrateMetadata,
        pub cstore: &'a CStore,
    }

Expand description

A reference to `CrateMetadata` that can also give access to whole crate store when necessary.

## Fields§

§`cdata: &'a CrateMetadata`§`cstore: &'a CStore`

## Implementations§

Source§

### impl<'a> CrateMetadataRef<'a>

Source

#### fn missing(self, descr: &str, id: DefIndex) -> !

Source

#### fn raw_proc_macro(self, tcx: TyCtxt<'_>, id: DefIndex) -> &'a ProcMacro

Source

#### fn opt_item_name(self, item_index: DefIndex) -> Option<Symbol>

Source

#### fn item_name(self, item_index: DefIndex) -> Symbol

Source

#### fn opt_item_ident(self, tcx: TyCtxt<'_>, item_index: DefIndex) -> Option<Ident>

Source

#### fn item_ident(self, tcx: TyCtxt<'_>, item_index: DefIndex) -> Ident

Source

#### pub(super) fn map_encoded_cnum_to_current(self, cnum: CrateNum) -> CrateNum

Source

#### fn def_kind(self, tcx: TyCtxt<'_>, item_id: DefIndex) -> DefKind

Source

#### fn get_span(self, tcx: TyCtxt<'_>, index: DefIndex) -> Span

Source

#### fn load_proc_macro<'tcx>( self, tcx: TyCtxt<'tcx>, id: DefIndex, ) -> SyntaxExtension

Source

#### fn get_variant( self, tcx: TyCtxt<'_>, kind: DefKind, index: DefIndex, parent_did: DefId, ) -> (VariantIdx, VariantDef)

Source

#### fn get_adt_def<'tcx>(self, tcx: TyCtxt<'tcx>, item_id: DefIndex) -> AdtDef<'tcx>

Source

#### fn get_visibility(self, tcx: TyCtxt<'_>, id: DefIndex) -> Visibility<DefId>

Source

#### fn get_safety(self, tcx: TyCtxt<'_>, id: DefIndex) -> Safety

Source

#### fn get_default_field(self, tcx: TyCtxt<'_>, id: DefIndex) -> Option<DefId>

Source

#### fn get_expn_that_defined(self, tcx: TyCtxt<'_>, id: DefIndex) -> ExpnId

Source

#### fn get_debugger_visualizers( self, tcx: TyCtxt<'_>, ) -> Vec<DebuggerVisualizerFile>

Source

#### fn get_lib_features(self, tcx: TyCtxt<'_>) -> LibFeatures

Iterates over all the stability attributes in the given crate.

Source

#### fn get_stability_implications<'tcx>( self, tcx: TyCtxt<'tcx>, ) -> &'tcx [(Symbol, Symbol)]

Iterates over the stability implications in the given crate (when a `#[unstable]` attribute has an `implied_by` meta item, then the mapping from the implied feature to the actual feature is a stability implication).

Source

#### fn get_lang_items<'tcx>(self, tcx: TyCtxt<'tcx>) -> &'tcx [(DefId, LangItem)]

Iterates over the lang items in the given crate.

Source

#### fn get_stripped_cfg_items<'tcx>( self, tcx: TyCtxt<'tcx>, cnum: CrateNum, ) -> &'tcx [StrippedCfgItem]

Source

#### fn get_diagnostic_items(self, tcx: TyCtxt<'_>) -> DiagnosticItems

Iterates over the diagnostic items in the given crate.

Source

#### fn get_mod_child(self, tcx: TyCtxt<'_>, id: DefIndex) -> ModChild

Source

#### fn get_module_children( self, tcx: TyCtxt<'_>, id: DefIndex, ) -> impl Iterator<Item = ModChild>

Iterates over all named children of the given module, including both proper items and reexports. Module here is understood in name resolution sense - it can be a `mod` item, or a crate root, or an enum, or a trait.

Source

#### fn get_ambig_module_children( self, tcx: TyCtxt<'_>, id: DefIndex, ) -> impl Iterator<Item = AmbigModChild>

Source

#### fn is_ctfe_mir_available(self, tcx: TyCtxt<'_>, id: DefIndex) -> bool

Source

#### fn is_item_mir_available(self, tcx: TyCtxt<'_>, id: DefIndex) -> bool

Source

#### fn get_fn_has_self_parameter(self, tcx: TyCtxt<'_>, id: DefIndex) -> bool

Source

#### fn get_associated_item_or_field_def_ids( self, tcx: TyCtxt<'_>, id: DefIndex, ) -> impl Iterator<Item = DefId>

Source

#### fn get_associated_item(self, tcx: TyCtxt<'_>, id: DefIndex) -> AssocItem

Source

#### fn get_ctor( self, tcx: TyCtxt<'_>, node_id: DefIndex, ) -> Option<(CtorKind, DefId)>

Source

#### fn get_item_attrs( self, tcx: TyCtxt<'_>, id: DefIndex, ) -> impl Iterator<Item = Attribute>

Source

#### fn get_inherent_implementations_for_type<'tcx>( self, tcx: TyCtxt<'tcx>, id: DefIndex, ) -> &'tcx [DefId]

Source

#### fn get_traits(self, tcx: TyCtxt<'_>) -> impl Iterator<Item = DefId>

Decodes all traits in the crate (for rustdoc and rustc diagnostics).

Source

#### fn get_trait_impls(self, tcx: TyCtxt<'_>) -> impl Iterator<Item = DefId>

Decodes all trait impls in the crate (for rustdoc).

Source

#### fn get_incoherent_impls<'tcx>( self, tcx: TyCtxt<'tcx>, simp: SimplifiedType, ) -> &'tcx [DefId]

Source

#### fn get_implementations_of_trait<'tcx>( self, tcx: TyCtxt<'tcx>, trait_def_id: DefId, ) -> &'tcx [(DefId, Option<SimplifiedType>)]

Source

#### fn get_native_libraries( self, tcx: TyCtxt<'_>, ) -> impl Iterator<Item = NativeLib>

Source

#### fn get_proc_macro_quoted_span(self, tcx: TyCtxt<'_>, index: usize) -> Span

Source

#### fn get_foreign_modules( self, tcx: TyCtxt<'_>, ) -> impl Iterator<Item = ForeignModule>

Source

#### fn get_dylib_dependency_formats<'tcx>( self, tcx: TyCtxt<'tcx>, ) -> &'tcx [(CrateNum, LinkagePreference)]

Source

#### fn get_externally_implementable_items( self, tcx: TyCtxt<'_>, ) -> impl Iterator<Item = (DefId, (EiiDecl, Vec<(DefId, EiiImpl)>))>

Source

#### fn get_missing_lang_items<'tcx>(self, tcx: TyCtxt<'tcx>) -> &'tcx [LangItem]

Source

#### fn get_exportable_items(self, tcx: TyCtxt<'_>) -> impl Iterator<Item = DefId>

Source

#### fn get_stable_order_of_exportable_impls( self, tcx: TyCtxt<'_>, ) -> impl Iterator<Item = (DefId, usize)>

Source

#### fn exported_non_generic_symbols<'tcx>( self, tcx: TyCtxt<'tcx>, ) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)]

Source

#### fn exported_generic_symbols<'tcx>( self, tcx: TyCtxt<'tcx>, ) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportInfo)]

Source

#### fn get_macro(self, tcx: TyCtxt<'_>, id: DefIndex) -> MacroDef

Source

#### fn def_key(self, index: DefIndex) -> DefKey

Source

#### fn def_path(self, id: DefIndex) -> DefPath

Source

#### fn def_path_hash(self, index: DefIndex) -> DefPathHash

Source

#### fn def_path_hash_to_def_index(self, hash: DefPathHash) -> Option<DefIndex>

Source

#### fn expn_hash_to_expn_id( self, tcx: TyCtxt<'_>, index_guess: u32, hash: ExpnHash, ) -> ExpnId

Source

#### fn imported_source_file( self, tcx: TyCtxt<'_>, source_file_index: u32, ) -> ImportedSourceFile

Imports the source_map from an external crate into the source_map of the crate currently being compiled (the “local crate”).

The import algorithm works analogous to how AST items are inlined from an external crate’s metadata: For every SourceFile in the external source_map an ‘inline’ copy is created in the local source_map. The correspondence relation between external and local SourceFiles is recorded in the `ImportedSourceFile` objects returned from this function. When an item from an external crate is later inlined into this crate, this correspondence information is used to translate the span information of the inlined item so that it refers the correct positions in the local source_map (see `<decoder::DecodeContext as SpecializedDecoder<Span>>`).

The import algorithm in the function below will reuse SourceFiles already existing in the local source_map. For example, even if the SourceFile of some source file of libstd gets imported many times, there will only ever be one SourceFile object for the corresponding file in the local source_map.

Note that imported SourceFiles do not actually contain the source code of the file they represent, just information about length, line breaks, and multibyte characters. This information is enough to generate valid debuginfo for items inlined from other crates.

Proc macro crates don’t currently export spans, so this function does not have to work for them.

Source

#### fn get_attr_flags(self, tcx: TyCtxt<'_>, index: DefIndex) -> AttrFlags

Source

#### fn get_intrinsic(self, tcx: TyCtxt<'_>, index: DefIndex) -> Option<IntrinsicDef>

Source

#### fn get_doc_link_resolutions( self, tcx: TyCtxt<'_>, index: DefIndex, ) -> DocLinkResMap

Source

#### fn get_doc_link_traits_in_scope( self, tcx: TyCtxt<'_>, index: DefIndex, ) -> impl Iterator<Item = DefId>

## Methods from Deref<Target = CrateMetadata>§

Source

#### pub(crate) fn dependencies(&self) -> impl Iterator<Item = CrateNum>

Source

#### pub(crate) fn target_modifiers(&self) -> Vec<TargetModifier>

Source

#### pub(crate) fn source(&self) -> &CrateSource

Source

#### pub(crate) fn dep_kind(&self) -> CrateDepKind

Source

#### pub(crate) fn used(&self) -> bool

Source

#### pub(crate) fn required_panic_strategy(&self) -> Option<PanicStrategy>

Source

#### pub(crate) fn needs_panic_runtime(&self) -> bool

Source

#### pub(crate) fn is_private_dep(&self) -> bool

Source

#### pub(crate) fn is_panic_runtime(&self) -> bool

Source

#### pub(crate) fn is_profiler_runtime(&self) -> bool

Source

#### pub(crate) fn is_compiler_builtins(&self) -> bool

Source

#### pub(crate) fn needs_allocator(&self) -> bool

Source

#### pub(crate) fn has_global_allocator(&self) -> bool

Source

#### pub(crate) fn has_alloc_error_handler(&self) -> bool

Source

#### pub(crate) fn has_default_lib_allocator(&self) -> bool

Source

#### pub(crate) fn is_proc_macro_crate(&self) -> bool

Source

#### pub(crate) fn proc_macros_for_crate( &self, tcx: TyCtxt<'_>, krate: CrateNum, cstore: &CStore, ) -> impl Iterator<Item = DefId>

Source

#### pub(crate) fn name(&self) -> Symbol

Source

#### pub(crate) fn hash(&self) -> Svh

Source

#### pub(crate) fn has_async_drops(&self) -> bool

Source

#### fn num_def_ids(&self) -> usize

Source

#### fn local_def_id(&self, index: DefIndex) -> DefId

Source

#### fn reverse_translate_def_id(&self, did: DefId) -> Option<DefId>

## Trait Implementations§

Source§

### impl<'a> Clone for CrateMetadataRef<'a>

Source§

#### fn clone(&self) -> CrateMetadataRef<'a>

Returns a duplicate of the value. Read more
1.0.0§

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

Performs copy-assignment from `source`. Read more
Source§

### impl Deref for CrateMetadataRef<'_>

Source§

#### type Target = CrateMetadata

The resulting type after dereferencing.
Source§

#### fn deref(&self) -> &Self::Target

Dereferences the value.
Source§

### impl<'a> Copy for CrateMetadataRef<'a>

## Auto Trait Implementations§

§

### impl<'a> DynSend for CrateMetadataRef<'a>

§

### impl<'a> DynSync for CrateMetadataRef<'a>

§

### impl<'a> Freeze for CrateMetadataRef<'a>

§

### impl<'a> !RefUnwindSafe for CrateMetadataRef<'a>

§

### impl<'a> !Send for CrateMetadataRef<'a>

§

### impl<'a> !Sync for CrateMetadataRef<'a>

§

### impl<'a> Unpin for CrateMetadataRef<'a>

§

### impl<'a> !UnwindSafe for CrateMetadataRef<'a>

## Blanket Implementations§

§

### impl<T> Aligned for T

§

#### const ALIGN: Alignment

Alignment of `Self`.
§

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

§

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

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

### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

§

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

§

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

§

### impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for T
where T: Copy,

§

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

§

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

§

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

§

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

Immutably borrows from an owned value. Read more
§

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

§

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

Mutably borrows from an owned value. Read more
§

### impl<T> CloneToUninit for T
where T: Clone,

§

#### unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (`clone_to_uninit`)
Performs copy-assignment from `self` to `dest`. Read more
§

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

§

#### 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<_>>())`.

§

#### type Output = R

§

### impl<T> DynClone for T
where T: Clone,

§

#### fn __clone_box(&self, _: Private) -> *mut ()

§

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

§

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

Returns the argument unchanged.

§

### impl<T> Instrument for T

§

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

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

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

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

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

§

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

Calls `U::from(self)`.

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

§

### impl<T> IntoEither for T

§

#### 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
§

#### 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
§

### impl<P> IntoQueryParam<P> for P

§

#### fn into_query_param(self) -> P

§

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

§

#### type Error = !

§

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

§

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

§

### impl<T> Pointable for T

§

#### const ALIGN: usize

The alignment of pointer.
§

#### type Init = T

The type for initializers.
§

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

Initializes a with the given initializer. Read more
§

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

Dereferences the given pointer. Read more
§

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

Mutably dereferences the given pointer. Read more
§

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

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

### impl<P, T> Receiver for P
where P: Deref<Target = T> + ?Sized, T: ?Sized,

§

#### type Target = T

🔬This is a nightly-only experimental API. (`arbitrary_self_types`)
The target type on which the method may be called.
§

### impl<T> Same for T

§

#### type Output = T

Should always be `Self`
§

### impl<T> ToOwned for T
where T: Clone,

§

#### type Owned = T

The resulting type after obtaining ownership.
§

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

Creates owned data from borrowed data, usually by cloning. Read more
§

#### fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
§

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

§

#### type Error = Infallible

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

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

Performs the conversion.
§

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

§

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

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

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

Performs the conversion.
§

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

§

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

§

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

§

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

§

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

§

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

§

### impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

§

#### default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

§

### impl<T> WithSubscriber for T

§

#### 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
§

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

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

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