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

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, extern_crate: ExternCrate, )

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 iter_crate_data( &self, ) -> impl Iterator<Item = (CrateNum, &CrateMetadata)>

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