Struct CrateMetadata 

pub(crate) struct CrateMetadata {

    blob: MetadataBlob,
    root: CrateRoot,
    trait_impls: FxIndexMap<(u32, DefIndex), LazyArray<(DefIndex, Option<SimplifiedType>)>>,
    incoherent_impls: FxIndexMap<SimplifiedType, LazyArray<DefIndex>>,
    raw_proc_macros: Option<&'static [ProcMacro]>,
    source_map_import_info: Lock<Vec<Option<ImportedSourceFile>>>,
    def_path_hash_map: DefPathHashMapRef<'static>,
    expn_hash_map: OnceLock<UnhashMap<ExpnHash, ExpnIndex>>,
    alloc_decoding_state: AllocDecodingState,
    def_key_cache: Lock<FxHashMap<DefIndex, DefKey>>,
    cnum: CrateNum,
    cnum_map: IndexVec<CrateNum, CrateNum>,
    dep_kind: CrateDepKind,
    source: Arc<CrateSource>,
    private_dep: bool,
    host_hash: Option<Svh>,
    used: bool,
    hygiene_context: HygieneDecodeContext,
    extern_crate: Option<ExternCrate>,
}

Fields

blob: MetadataBlob

The primary crate data - binary metadata blob.

root: CrateRoot

Data about the top-level items in a crate, as well as various crate-level metadata.

trait_impls: FxIndexMap<(u32, DefIndex), LazyArray<(DefIndex, Option<SimplifiedType>)>>

Trait impl data. FIXME: Used only from queries and can use query cache, so pre-decoding can probably be avoided.

incoherent_impls: FxIndexMap<SimplifiedType, LazyArray<DefIndex>>

Inherent impls which do not follow the normal coherence rules.

These can be introduced using either #![rustc_coherence_is_core] or #[rustc_allow_incoherent_impl].

raw_proc_macros: Option<&'static [ProcMacro]>

Proc macro descriptions for this crate, if it’s a proc macro crate.

source_map_import_info: Lock<Vec<Option<ImportedSourceFile>>>

Source maps for code from the crate.

def_path_hash_map: DefPathHashMapRef<'static>

For every definition in this crate, maps its DefPathHash to its DefIndex.

expn_hash_map: OnceLock<UnhashMap<ExpnHash, ExpnIndex>>

Likewise for ExpnHash.

alloc_decoding_state: AllocDecodingState

Used for decoding interpret::AllocIds in a cached & thread-safe manner.

def_key_cache: Lock<FxHashMap<DefIndex, DefKey>>

Caches decoded DefKeys.

cnum: CrateNum

ID of this crate, from the current compilation session’s point of view.

cnum_map: IndexVec<CrateNum, CrateNum>

Maps crate IDs as they are were seen from this crate’s compilation sessions into IDs as they are seen from the current compilation session.

dep_kind: CrateDepKind

How to link (or not link) this crate to the currently compiled crate.

source: Arc<CrateSource>

Filesystem location of this crate.

private_dep: bool

Whether or not this crate should be consider a private dependency. Used by the ‘exported_private_dependencies’ lint, and for determining whether to emit suggestions that reference this crate.

host_hash: Option<Svh>

The hash for the host proc macro. Used to support -Z dual-proc-macro.

used: bool

The crate was used non-speculatively.

hygiene_context: HygieneDecodeContext

Additional data used for decoding HygieneData (e.g. SyntaxContext and ExpnId). Note that we store a HygieneDecodeContext for each CrateMetadata. This is because SyntaxContext ids are not globally unique, so we need to track which ids we’ve decoded on a per-crate basis.

extern_crate: Option<ExternCrate>

Information about the extern crate item or path that caused this crate to be loaded. If this is None, then the crate was injected (e.g., by the allocator).

Implementations

impl CrateMetadata

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

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

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

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

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

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

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

fn def_kind(&self, item_id: DefIndex) -> DefKind

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

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

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

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

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

fn get_safety(&self, id: DefIndex) -> Safety

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

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

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

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

Iterates over all the stability attributes in the given crate.

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).

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

Iterates over the lang items in the given crate.

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

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

Iterates over the diagnostic items in the given crate.

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

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.

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

fn is_item_mir_available(&self, id: DefIndex) -> bool

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

fn get_attr_flags(&self, index: DefIndex) -> AttrFlags

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

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

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

impl CrateMetadata

pub(crate) fn new( tcx: TyCtxt<'_>, blob: MetadataBlob, root: CrateRoot, raw_proc_macros: Option<&'static [ProcMacro]>, cnum: CrateNum, cnum_map: IndexVec<CrateNum, CrateNum>, dep_kind: CrateDepKind, source: CrateSource, private_dep: bool, host_hash: Option<Svh>, ) -> CrateMetadata

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

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

pub(crate) fn enabled_denied_partial_mitigations( &self, ) -> Vec<DeniedPartialMitigation>

pub(crate) fn update_extern_crate_diagnostics( &mut self, new_extern_crate: ExternCrate, ) -> bool

Keep new_extern_crate if it looks better in diagnostics

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

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

pub(crate) fn set_dep_kind(&mut self, dep_kind: CrateDepKind)

pub(crate) fn update_and_private_dep(&mut self, private_dep: bool)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn num_def_ids(&self) -> usize

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

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

Trait Implementations

impl<'a> MetaBlob<'a> for &'a CrateMetadata

fn blob(&self) -> &'a MetadataBlob

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: 3040 bytes