Struct CStore 

pub struct CStore {
    metadata_loader: Box<MetadataLoaderDyn>,
    metas: IndexVec<CrateNum, Option<Box<CrateMetadata>>>,
    injected_panic_runtime: Option<CrateNum>,
    allocator_kind: Option<AllocatorKind>,
    alloc_error_handler_kind: Option<AllocatorKind>,
    has_global_allocator: bool,
    has_alloc_error_handler: bool,
    resolved_externs: UnordMap<Symbol, CrateNum>,
    unused_externs: Vec<Symbol>,
    used_extern_options: FxHashSet<Symbol>,
}

Fields

metadata_loader: Box<MetadataLoaderDyn>

metas: IndexVec<CrateNum, Option<Box<CrateMetadata>>>

injected_panic_runtime: Option<CrateNum>

allocator_kind: Option<AllocatorKind>

This crate needs an allocator and either provides it itself, or finds it in a dependency. If the above is true, then this field denotes the kind of the found allocator.

alloc_error_handler_kind: Option<AllocatorKind>

This crate needs an allocation error handler and either provides it itself, or finds it in a dependency. If the above is true, then this field denotes the kind of the found allocator.

has_global_allocator: bool

This crate has a #[global_allocator] item.

has_alloc_error_handler: bool

This crate has a #[alloc_error_handler] item.

resolved_externs: UnordMap<Symbol, CrateNum>

Names that were used to load the crates via extern crate or paths.

unused_externs: Vec<Symbol>

Unused externs of the crate

used_extern_options: FxHashSet<Symbol>

Implementations

impl CStore

pub fn ctor_untracked(&self, def: DefId) -> Option<(CtorKind, DefId)>

pub fn load_macro_untracked(&self, id: DefId, tcx: TyCtxt<'_>) -> LoadedMacro

pub fn def_span_untracked(&self, def_id: DefId, sess: &Session) -> Span

pub fn def_kind_untracked(&self, def: DefId) -> DefKind

pub fn expn_that_defined_untracked( &self, def_id: DefId, sess: &Session, ) -> ExpnId

pub fn num_def_ids_untracked(&self, cnum: CrateNum) -> usize

Only public-facing way to traverse all the definitions in a non-local crate. Critically useful for this third-party project: https://github.com/hacspec/hacspec. See https://github.com/rust-lang/rust/pull/85889 for context.

pub fn get_proc_macro_quoted_span_untracked( &self, cnum: CrateNum, id: usize, sess: &Session, ) -> Span

pub fn set_used_recursively(&mut self, cnum: CrateNum)

pub(crate) fn update_extern_crate( &mut self, cnum: CrateNum, name: Symbol, extern_crate: ExternCrate, )

Track how an extern crate has been loaded. Called after resolving an import in the local crate.

• the name is for Self::set_resolved_extern_crate_name saving --extern name=
• extern_crate is for diagnostics

fn update_transitive_extern_crate_diagnostics( &mut self, cnum: CrateNum, extern_crate: ExternCrate, )

CrateMetadata uses ExternCrate only for diagnostics

impl CStore

pub fn from_tcx(tcx: TyCtxt<'_>) -> FreezeReadGuard<'_, CStore>

pub fn from_tcx_mut(tcx: TyCtxt<'_>) -> FreezeWriteGuard<'_, CStore>

fn intern_stable_crate_id<'tcx>( &mut self, tcx: TyCtxt<'tcx>, root: &CrateRoot, ) -> Result<TyCtxtFeed<'tcx, CrateNum>, CrateError>

pub fn has_crate_data(&self, cnum: CrateNum) -> bool

pub(crate) fn get_crate_data(&self, cnum: CrateNum) -> CrateMetadataRef<'_>

pub(crate) fn get_crate_data_mut( &mut self, cnum: CrateNum, ) -> &mut CrateMetadata

fn set_crate_data(&mut self, cnum: CrateNum, data: CrateMetadata)

pub(crate) fn set_resolved_extern_crate_name( &mut self, name: Symbol, extern_crate: CrateNum, )

Save the name used to resolve the extern crate in the local crate

The name isn’t always the crate’s own name, because sess.opts.externs can assign it another name. It’s also not always the same as the DefId’s symbol due to renames extern crate resolved_name as defid_name.

pub fn resolved_extern_crate(&self, externs_name: Symbol) -> Option<CrateNum>

Crate resolved and loaded via the given extern name (corresponds to names in sess.opts.externs)

May be None if the crate wasn’t used

pub(crate) fn iter_crate_data( &self, ) -> impl Iterator<Item = (CrateNum, &CrateMetadata)>

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

fn push_dependencies_in_postorder( &self, deps: &mut IndexSet<CrateNum>, cnum: CrateNum, )

pub(crate) fn crate_dependencies_in_postorder( &self, cnum: CrateNum, ) -> IndexSet<CrateNum>

pub(crate) fn injected_panic_runtime(&self) -> Option<CrateNum>

pub(crate) fn allocator_kind(&self) -> Option<AllocatorKind>

pub(crate) fn alloc_error_handler_kind(&self) -> Option<AllocatorKind>

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

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

pub fn report_unused_deps(&self, tcx: TyCtxt<'_>)

fn report_target_modifiers_extended( tcx: TyCtxt<'_>, krate: &Crate, mods: &Vec<TargetModifier>, dep_mods: &Vec<TargetModifier>, data: &CrateMetadata, )

pub fn report_incompatible_target_modifiers( &self, tcx: TyCtxt<'_>, krate: &Crate, )

pub fn report_incompatible_async_drop_feature( &self, tcx: TyCtxt<'_>, krate: &Crate, )

pub fn new(metadata_loader: Box<MetadataLoaderDyn>) -> CStore

fn existing_match( &self, externs: &Externs, name: Symbol, hash: Option<Svh>, kind: PathKind, ) -> Option<CrateNum>

fn is_private_dep( &self, externs: &Externs, name: Symbol, private_dep: Option<bool>, origin: CrateOrigin<'_>, ) -> bool

Determine whether a dependency should be considered private.

Dependencies are private if they get extern option specified, e.g. --extern priv:mycrate. This is stored in metadata, so private_dep can be correctly set during load. A Some value for private_dep indicates that the crate is known to be private or public (note that any None or Some(false) use of the same crate will make it public).

Sometimes the directly dependent crate is not specified by --extern, in this case, private-dep is none during loading. This is equivalent to the scenario where the command parameter is set to public-dependency

fn register_crate<'tcx>( &mut self, tcx: TyCtxt<'tcx>, host_lib: Option<Library>, origin: CrateOrigin<'_>, lib: Library, dep_kind: CrateDepKind, name: Symbol, private_dep: Option<bool>, ) -> Result<CrateNum, CrateError>

fn load_proc_macro<'a, 'b>( &self, sess: &'a Session, locator: &mut CrateLocator<'b>, crate_rejections: &mut CrateRejections, path_kind: PathKind, host_hash: Option<Svh>, ) -> Result<Option<(LoadResult, Option<Library>)>, CrateError>

where 'a: 'b,

fn resolve_crate<'tcx>( &mut self, tcx: TyCtxt<'tcx>, name: Symbol, span: Span, dep_kind: CrateDepKind, origin: CrateOrigin<'_>, ) -> Option<CrateNum>

fn maybe_resolve_crate<'b, 'tcx>( &'b mut self, tcx: TyCtxt<'tcx>, name: Symbol, dep_kind: CrateDepKind, origin: CrateOrigin<'b>, ) -> Result<CrateNum, CrateError>

fn load( &self, locator: &CrateLocator<'_>, crate_rejections: &mut CrateRejections, ) -> Result<Option<LoadResult>, CrateError>

fn resolve_crate_deps( &mut self, tcx: TyCtxt<'_>, dep_root: &CratePaths, crate_root: &CrateRoot, metadata: &MetadataBlob, krate: CrateNum, dep_kind: CrateDepKind, parent_is_private: bool, ) -> Result<IndexVec<CrateNum, CrateNum>, CrateError>

Go through the crate metadata and load any crates that it references.

fn dlsym_proc_macros( &self, sess: &Session, path: &Path, stable_crate_id: StableCrateId, ) -> Result<&'static [ProcMacro], CrateError>

fn inject_panic_runtime(&mut self, tcx: TyCtxt<'_>, krate: &Crate)

fn inject_profiler_runtime(&mut self, tcx: TyCtxt<'_>)

fn inject_allocator_crate(&mut self, tcx: TyCtxt<'_>, krate: &Crate)

fn inject_forced_externs(&mut self, tcx: TyCtxt<'_>)

fn inject_compiler_builtins(&mut self, tcx: TyCtxt<'_>, krate: &Crate)

Inject the compiler_builtins crate if it is not already in the graph.

fn report_unused_deps_in_crate(&mut self, tcx: TyCtxt<'_>, krate: &Crate)

fn report_future_incompatible_deps(&self, tcx: TyCtxt<'_>, krate: &Crate)

pub fn postprocess(&mut self, tcx: TyCtxt<'_>, krate: &Crate)

pub fn process_extern_crate( &mut self, tcx: TyCtxt<'_>, item: &Item, def_id: LocalDefId, definitions: &Definitions, ) -> Option<CrateNum>

Process an extern crate foo AST node.

pub fn process_path_extern( &mut self, tcx: TyCtxt<'_>, name: Symbol, span: Span, ) -> Option<CrateNum>

pub fn maybe_process_path_extern( &mut self, tcx: TyCtxt<'_>, name: Symbol, ) -> Option<CrateNum>

Trait Implementations

impl CrateStore for CStore

fn def_key(&self, def: DefId) -> DefKey

Returns the DefKey for a given DefId. This indicates the parent DefId as well as some idea of what kind of data the DefId refers to.

fn as_any(&self) -> &dyn Any

fn untracked_as_any(&mut self) -> &mut dyn Any

fn crate_name(&self, cnum: CrateNum) -> Symbol

fn stable_crate_id(&self, cnum: CrateNum) -> StableCrateId

fn def_path(&self, def: DefId) -> DefPath

fn def_path_hash(&self, def: DefId) -> DefPathHash

impl Debug for CStore

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

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