Struct rustc_metadata::cstore::CStore

pub struct CStore {
    pub dep_graph: DepGraph,
    pub intr: Rc<IdentInterner>,
    pub visible_parent_map: RefCell<DefIdMap<DefId>>,
    // some fields omitted
}

Unstable (rustc_private)

Fields

dep_graph: DepGraph

Unstable (rustc_private)

intr: Rc<IdentInterner>

Unstable (rustc_private)

visible_parent_map: RefCell<DefIdMap<DefId>>

Unstable (rustc_private)

Methods

impl CStore

fn new(dep_graph: &DepGraph, intr: Rc<IdentInterner>) -> CStore

fn next_crate_num(&self) -> CrateNum

fn get_crate_data(&self, cnum: CrateNum) -> Rc<crate_metadata>

fn get_crate_hash(&self, cnum: CrateNum) -> Svh

fn set_crate_data(&self, cnum: CrateNum, data: Rc<crate_metadata>)

fn iter_crate_data<I>(&self, i: I) where I: FnMut(CrateNum, &Rc<crate_metadata>)

fn iter_crate_data_origins<I>(&self, i: I) where I: FnMut(CrateNum, &crate_metadata, Option<CrateSource>)

Unstable (rustc_private)

Like iter_crate_data, but passes source paths (if available) as well.

fn add_used_crate_source(&self, src: CrateSource)

fn opt_used_crate_source(&self, cnum: CrateNum) -> Option<CrateSource>

fn reset(&self)

fn do_get_used_crates(&self, prefer: LinkagePreference) -> Vec<(CrateNum, Option<PathBuf>)>

fn add_used_library(&self, lib: String, kind: NativeLibraryKind)

fn get_used_libraries<'a>(&'a self) -> &'a RefCell<Vec<(String, NativeLibraryKind)>>

fn add_used_link_args(&self, args: &str)

fn get_used_link_args<'a>(&'a self) -> &'a RefCell<Vec<String>>

fn add_extern_mod_stmt_cnum(&self, emod_id: NodeId, cnum: CrateNum)

fn add_statically_included_foreign_item(&self, id: NodeId)

fn do_is_statically_included_foreign_item(&self, id: NodeId) -> bool

fn do_extern_mod_stmt_cnum(&self, emod_id: NodeId) -> Option<CrateNum>

Trait Implementations

impl<'tcx> CrateStore<'tcx> for CStore

fn stability(&self, def: DefId) -> Option<Stability>

fn deprecation(&self, def: DefId) -> Option<Deprecation>

fn visibility(&self, def: DefId) -> Visibility

fn closure_kind(&self, def_id: DefId) -> ClosureKind

fn closure_ty<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> ClosureTy<'tcx>

fn item_variances(&self, def: DefId) -> ItemVariances

fn repr_attrs(&self, def: DefId) -> Vec<ReprAttr>

fn item_type<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> TypeScheme<'tcx>

fn item_predicates<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> GenericPredicates<'tcx>

fn item_super_predicates<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> GenericPredicates<'tcx>

fn item_attrs(&self, def_id: DefId) -> Vec<Attribute>

fn item_symbol(&self, def: DefId) -> String

fn trait_def<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> TraitDef<'tcx>

fn adt_def<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> AdtDefMaster<'tcx>

fn method_arg_names(&self, did: DefId) -> Vec<String>

fn item_name(&self, def: DefId) -> Name

fn inherent_implementations_for_type(&self, def_id: DefId) -> Vec<DefId>

fn implementations_of_trait(&self, def_id: DefId) -> Vec<DefId>

fn provided_trait_methods<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> Vec<Rc<Method<'tcx>>>

fn trait_item_def_ids(&self, def: DefId) -> Vec<ImplOrTraitItemId>

fn impl_items(&self, impl_def_id: DefId) -> Vec<ImplOrTraitItemId>

fn impl_polarity(&self, def: DefId) -> Option<ImplPolarity>

fn impl_trait_ref<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> Option<TraitRef<'tcx>>

fn custom_coerce_unsized_kind(&self, def: DefId) -> Option<CustomCoerceUnsized>

fn associated_consts<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> Vec<Rc<AssociatedConst<'tcx>>>

fn impl_parent(&self, impl_def: DefId) -> Option<DefId>

fn trait_of_item<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def_id: DefId) -> Option<DefId>

fn impl_or_trait_item<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> Option<ImplOrTraitItem<'tcx>>

fn is_const_fn(&self, did: DefId) -> bool

fn is_defaulted_trait(&self, trait_def_id: DefId) -> bool

fn is_impl(&self, did: DefId) -> bool

fn is_default_impl(&self, impl_did: DefId) -> bool

fn is_extern_item<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, did: DefId) -> bool

fn is_static_method(&self, def: DefId) -> bool

fn is_statically_included_foreign_item(&self, id: NodeId) -> bool

fn is_typedef(&self, did: DefId) -> bool

fn dylib_dependency_formats(&self, cnum: CrateNum) -> Vec<(CrateNum, LinkagePreference)>

fn lang_items(&self, cnum: CrateNum) -> Vec<(DefIndex, usize)>

fn missing_lang_items(&self, cnum: CrateNum) -> Vec<LangItem>

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

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

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

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

fn panic_strategy(&self, cnum: CrateNum) -> PanicStrategy

fn crate_attrs(&self, cnum: CrateNum) -> Vec<Attribute>

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

The name of the crate as it is referred to in source code of the current crate.

fn original_crate_name(&self, cnum: CrateNum) -> InternedString

The name of the crate as it is stored in the crate's metadata.

fn extern_crate(&self, cnum: CrateNum) -> Option<ExternCrate>

fn crate_hash(&self, cnum: CrateNum) -> Svh

fn crate_disambiguator(&self, cnum: CrateNum) -> InternedString

fn crate_struct_field_attrs(&self, cnum: CrateNum) -> FnvHashMap<DefId, Vec<Attribute>>

fn plugin_registrar_fn(&self, cnum: CrateNum) -> Option<DefId>

fn native_libraries(&self, cnum: CrateNum) -> Vec<(NativeLibraryKind, String)>

fn reachable_ids(&self, cnum: CrateNum) -> Vec<DefId>

fn def_index_for_def_key(&self, cnum: CrateNum, def: DefKey) -> Option<DefIndex>

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

Unstable (rustc_private)

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 relative_def_path(&self, def: DefId) -> DefPath

fn variant_kind(&self, def_id: DefId) -> Option<VariantKind>

fn struct_ctor_def_id(&self, struct_def_id: DefId) -> Option<DefId>

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

fn struct_field_names(&self, def: DefId) -> Vec<Name>

fn item_children(&self, def_id: DefId) -> Vec<ChildItem>

fn crate_top_level_items(&self, cnum: CrateNum) -> Vec<ChildItem>

fn maybe_get_item_ast<'a>(&'tcx self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> FoundAst<'tcx>

fn maybe_get_item_mir<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, def: DefId) -> Option<Mir<'tcx>>

fn is_item_mir_available(&self, def: DefId) -> bool

fn crates(&self) -> Vec<CrateNum>

fn used_libraries(&self) -> Vec<(String, NativeLibraryKind)>

fn used_link_args(&self) -> Vec<String>

fn metadata_filename(&self) -> &str

fn metadata_section_name(&self, target: &Target) -> &str

fn encode_type<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, ty: Ty<'tcx>, def_id_to_string: fn<'b>(TyCtxt<'b, 'tcx, 'tcx>, DefId) -> String) -> Vec<u8>

fn used_crates(&self, prefer: LinkagePreference) -> Vec<(CrateNum, Option<PathBuf>)>

fn used_crate_source(&self, cnum: CrateNum) -> CrateSource

fn extern_mod_stmt_cnum(&self, emod_id: NodeId) -> Option<CrateNum>

fn encode_metadata<'a>(&self, tcx: TyCtxt<'a, 'tcx, 'tcx>, reexports: &ExportMap, item_symbols: &RefCell<NodeMap<String>>, link_meta: &LinkMeta, reachable: &NodeSet, mir_map: &MirMap<'tcx>, krate: &Crate) -> Vec<u8>

fn metadata_encoding_version(&self) -> &[u8]

fn visible_parent_map<'a>(&'a self) -> RefMut<'a, DefIdMap<DefId>>

Unstable (rustc_private)

Returns a map from a sufficiently visible external item (i.e. an external item that is visible from at least one local module) to a sufficiently visible parent (considering modules that re-export the external item to be parents).