1 //! the rustc crate store interface. This also includes types that
2 //! are *mostly* used as a part of that interface, but these should
3 //! probably get a better home if someone can find one.
5 use crate::search_paths
::PathKind
;
6 use crate::utils
::NativeLibKind
;
9 use rustc_data_structures
::sync
::{self, MetadataRef}
;
10 use rustc_hir
::def_id
::{CrateNum, DefId, StableCrateId, LOCAL_CRATE}
;
11 use rustc_hir
::definitions
::{DefKey, DefPath, DefPathHash}
;
12 use rustc_span
::hygiene
::{ExpnHash, ExpnId}
;
13 use rustc_span
::symbol
::Symbol
;
15 use rustc_target
::spec
::Target
;
18 use std
::path
::{Path, PathBuf}
;
20 // lonely orphan structs and enums looking for a better home
22 /// Where a crate came from on the local filesystem. One of these three options
24 #[derive(PartialEq, Clone, Debug, HashStable_Generic, Encodable, Decodable)]
25 pub struct CrateSource
{
26 pub dylib
: Option
<(PathBuf
, PathKind
)>,
27 pub rlib
: Option
<(PathBuf
, PathKind
)>,
28 pub rmeta
: Option
<(PathBuf
, PathKind
)>,
33 pub fn paths(&self) -> impl Iterator
<Item
= &PathBuf
> {
34 self.dylib
.iter().chain(self.rlib
.iter()).chain(self.rmeta
.iter()).map(|p
| &p
.0)
38 #[derive(Encodable, Decodable, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
39 #[derive(HashStable_Generic)]
40 pub enum CrateDepKind
{
41 /// A dependency that is only used for its macros.
43 /// A dependency that is always injected into the dependency list and so
44 /// doesn't need to be linked to an rlib, e.g., the injected allocator.
46 /// A dependency that is required by an rlib version of this crate.
47 /// Ordinary `extern crate`s result in `Explicit` dependencies.
53 pub fn macros_only(self) -> bool
{
55 CrateDepKind
::MacrosOnly
=> true,
56 CrateDepKind
::Implicit
| CrateDepKind
::Explicit
=> false,
61 #[derive(Copy, Debug, PartialEq, Clone, Encodable, Decodable, HashStable_Generic)]
62 pub enum LinkagePreference
{
67 #[derive(Debug, Encodable, Decodable, HashStable_Generic)]
68 pub struct NativeLib
{
69 pub kind
: NativeLibKind
,
70 pub name
: Option
<Symbol
>,
71 pub cfg
: Option
<ast
::MetaItem
>,
72 pub foreign_module
: Option
<DefId
>,
73 pub wasm_import_module
: Option
<Symbol
>,
74 pub verbatim
: Option
<bool
>,
75 pub dll_imports
: Vec
<DllImport
>,
78 #[derive(Clone, Debug, Encodable, Decodable, HashStable_Generic)]
79 pub struct DllImport
{
81 pub ordinal
: Option
<u16>,
82 /// Calling convention for the function.
84 /// On x86_64, this is always `DllCallingConvention::C`; on i686, it can be any
85 /// of the values, and we use `DllCallingConvention::C` to represent `"cdecl"`.
86 pub calling_convention
: DllCallingConvention
,
87 /// Span of import's "extern" declaration; used for diagnostics.
91 /// Calling convention for a function defined in an external library.
93 /// The usize value, where present, indicates the size of the function's argument list
95 #[derive(Clone, PartialEq, Debug, Encodable, Decodable, HashStable_Generic)]
96 pub enum DllCallingConvention
{
103 #[derive(Clone, Encodable, Decodable, HashStable_Generic, Debug)]
104 pub struct ForeignModule
{
105 pub foreign_items
: Vec
<DefId
>,
109 #[derive(Copy, Clone, Debug, HashStable_Generic)]
110 pub struct ExternCrate
{
111 pub src
: ExternCrateSource
,
113 /// span of the extern crate that caused this to be loaded
116 /// Number of links to reach the extern;
117 /// used to select the extern with the shortest path
120 /// Crate that depends on this crate
121 pub dependency_of
: CrateNum
,
125 /// If true, then this crate is the crate named by the extern
126 /// crate referenced above. If false, then this crate is a dep
129 pub fn is_direct(&self) -> bool
{
130 self.dependency_of
== LOCAL_CRATE
134 pub fn rank(&self) -> impl PartialOrd
{
136 // - direct extern crate to indirect
137 // - shorter paths to longer
138 (self.is_direct(), !self.path_len
)
142 #[derive(Copy, Clone, Debug, HashStable_Generic)]
143 pub enum ExternCrateSource
{
144 /// Crate is loaded by `extern crate`.
146 /// def_id of the item in the current crate that caused
147 /// this crate to be loaded; note that there could be multiple
151 /// Crate is implicitly loaded by a path resolving through extern prelude.
155 /// The backend's way to give the crate store access to the metadata in a library.
156 /// Note that it returns the raw metadata bytes stored in the library file, whether
157 /// it is compressed, uncompressed, some weird mix, etc.
158 /// rmeta files are backend independent and not handled here.
160 /// At the time of this writing, there is only one backend and one way to store
161 /// metadata in library -- this trait just serves to decouple rustc_metadata from
162 /// the archive reader, which depends on LLVM.
163 pub trait MetadataLoader
{
164 fn get_rlib_metadata(&self, target
: &Target
, filename
: &Path
) -> Result
<MetadataRef
, String
>;
165 fn get_dylib_metadata(&self, target
: &Target
, filename
: &Path
) -> Result
<MetadataRef
, String
>;
168 pub type MetadataLoaderDyn
= dyn MetadataLoader
+ Sync
;
170 /// A store of Rust crates, through which their metadata can be accessed.
172 /// Note that this trait should probably not be expanding today. All new
173 /// functionality should be driven through queries instead!
175 /// If you find a method on this trait named `{name}_untracked` it signifies
176 /// that it's *not* tracked for dependency information throughout compilation
177 /// (it'd break incremental compilation) and should only be called pre-HIR (e.g.
179 pub trait CrateStore
: std
::fmt
::Debug
{
180 fn as_any(&self) -> &dyn Any
;
182 // Foreign definitions.
183 // This information is safe to access, since it's hashed as part of the DefPathHash, which incr.
184 // comp. uses to identify a DefId.
185 fn def_key(&self, def
: DefId
) -> DefKey
;
186 fn def_path(&self, def
: DefId
) -> DefPath
;
187 fn def_path_hash(&self, def
: DefId
) -> DefPathHash
;
189 // This information is safe to access, since it's hashed as part of the StableCrateId, which
190 // incr. comp. uses to identify a CrateNum.
191 fn crate_name(&self, cnum
: CrateNum
) -> Symbol
;
192 fn stable_crate_id(&self, cnum
: CrateNum
) -> StableCrateId
;
193 fn stable_crate_id_to_crate_num(&self, stable_crate_id
: StableCrateId
) -> CrateNum
;
195 /// Fetch a DefId from a DefPathHash for a foreign crate.
196 fn def_path_hash_to_def_id(&self, cnum
: CrateNum
, hash
: DefPathHash
) -> DefId
;
197 fn expn_hash_to_expn_id(
206 pub type CrateStoreDyn
= dyn CrateStore
+ sync
::Sync
;