1 use crate::dep_graph
::{DepNode, DepNodeIndex, SerializedDepNodeIndex}
;
2 use crate::mir
::interpret
::{AllocDecodingSession, AllocDecodingState}
;
3 use crate::mir
::{self, interpret}
;
4 use crate::ty
::codec
::{RefDecodable, TyDecoder, TyEncoder}
;
5 use crate::ty
::context
::TyCtxt
;
6 use crate::ty
::{self, Ty}
;
7 use rustc_data_structures
::fingerprint
::{Fingerprint, FingerprintDecoder, FingerprintEncoder}
;
8 use rustc_data_structures
::fx
::{FxHashMap, FxHashSet, FxIndexSet}
;
9 use rustc_data_structures
::sync
::{HashMapExt, Lock, Lrc, OnceCell}
;
10 use rustc_data_structures
::thin_vec
::ThinVec
;
11 use rustc_data_structures
::unhash
::UnhashMap
;
12 use rustc_errors
::Diagnostic
;
13 use rustc_hir
::def_id
::{CrateNum, DefId, DefIndex, LocalDefId, LOCAL_CRATE}
;
14 use rustc_hir
::definitions
::DefPathHash
;
15 use rustc_hir
::definitions
::Definitions
;
16 use rustc_index
::vec
::{Idx, IndexVec}
;
17 use rustc_serialize
::{
18 opaque
::{self, FileEncodeResult, FileEncoder}
,
19 Decodable
, Decoder
, Encodable
, Encoder
,
21 use rustc_session
::{CrateDisambiguator, Session}
;
22 use rustc_span
::hygiene
::{
23 ExpnDataDecodeMode
, ExpnDataEncodeMode
, ExpnId
, HygieneDecodeContext
, HygieneEncodeContext
,
24 SyntaxContext
, SyntaxContextData
,
26 use rustc_span
::source_map
::{SourceMap, StableSourceFileId}
;
27 use rustc_span
::CachingSourceMapView
;
28 use rustc_span
::{BytePos, ExpnData, SourceFile, Span, DUMMY_SP}
;
29 use std
::collections
::hash_map
::Entry
;
30 use std
::iter
::FromIterator
;
33 const TAG_FILE_FOOTER
: u128
= 0xC0FFEE_C0FFEE_C0FFEE_C0FFEE_C0FFEE;
35 // A normal span encoded with both location information and a `SyntaxContext`
36 const TAG_FULL_SPAN
: u8 = 0;
37 // A partial span with no location information, encoded only with a `SyntaxContext`
38 const TAG_PARTIAL_SPAN
: u8 = 1;
40 const TAG_SYNTAX_CONTEXT
: u8 = 0;
41 const TAG_EXPN_DATA
: u8 = 1;
43 /// Provides an interface to incremental compilation data cached from the
44 /// previous compilation session. This data will eventually include the results
45 /// of a few selected queries (like `typeck` and `mir_optimized`) and
46 /// any diagnostics that have been emitted during a query.
47 pub struct OnDiskCache
<'sess
> {
48 // The complete cache data in serialized form.
49 serialized_data
: Vec
<u8>,
51 // Collects all `Diagnostic`s emitted during the current compilation
53 current_diagnostics
: Lock
<FxHashMap
<DepNodeIndex
, Vec
<Diagnostic
>>>,
55 prev_cnums
: Vec
<(u32, String
, CrateDisambiguator
)>,
56 cnum_map
: OnceCell
<IndexVec
<CrateNum
, Option
<CrateNum
>>>,
58 source_map
: &'sess SourceMap
,
59 file_index_to_stable_id
: FxHashMap
<SourceFileIndex
, StableSourceFileId
>,
61 // Caches that are populated lazily during decoding.
62 file_index_to_file
: Lock
<FxHashMap
<SourceFileIndex
, Lrc
<SourceFile
>>>,
64 // A map from dep-node to the position of the cached query result in
66 query_result_index
: FxHashMap
<SerializedDepNodeIndex
, AbsoluteBytePos
>,
68 // A map from dep-node to the position of any associated diagnostics in
70 prev_diagnostics_index
: FxHashMap
<SerializedDepNodeIndex
, AbsoluteBytePos
>,
72 alloc_decoding_state
: AllocDecodingState
,
74 // A map from syntax context ids to the position of their associated
75 // `SyntaxContextData`. We use a `u32` instead of a `SyntaxContext`
76 // to represent the fact that we are storing *encoded* ids. When we decode
77 // a `SyntaxContext`, a new id will be allocated from the global `HygieneData`,
78 // which will almost certainly be different than the serialized id.
79 syntax_contexts
: FxHashMap
<u32, AbsoluteBytePos
>,
80 // A map from the `DefPathHash` of an `ExpnId` to the position
81 // of their associated `ExpnData`. Ideally, we would store a `DefId`,
82 // but we need to decode this before we've constructed a `TyCtxt` (which
83 // makes it difficult to decode a `DefId`).
85 // Note that these `DefPathHashes` correspond to both local and foreign
86 // `ExpnData` (e.g `ExpnData.krate` may not be `LOCAL_CRATE`). Alternatively,
87 // we could look up the `ExpnData` from the metadata of foreign crates,
88 // but it seemed easier to have `OnDiskCache` be independent of the `CStore`.
89 expn_data
: FxHashMap
<u32, AbsoluteBytePos
>,
90 // Additional information used when decoding hygiene data.
91 hygiene_context
: HygieneDecodeContext
,
92 // Maps `DefPathHash`es to their `RawDefId`s from the *previous*
93 // compilation session. This is used as an initial 'guess' when
94 // we try to map a `DefPathHash` to its `DefId` in the current compilation
96 foreign_def_path_hashes
: UnhashMap
<DefPathHash
, RawDefId
>,
98 // The *next* compilation sessison's `foreign_def_path_hashes` - at
99 // the end of our current compilation session, this will get written
100 // out to the `foreign_def_path_hashes` field of the `Footer`, which
101 // will become `foreign_def_path_hashes` of the next compilation session.
102 // This stores any `DefPathHash` that we may need to map to a `DefId`
103 // during the next compilation session.
104 latest_foreign_def_path_hashes
: Lock
<UnhashMap
<DefPathHash
, RawDefId
>>,
106 // Maps `DefPathHashes` to their corresponding `LocalDefId`s for all
107 // local items in the current compilation session. This is only populated
108 // when we are in incremental mode and have loaded a pre-existing cache
109 // from disk, since this map is only used when deserializing a `DefPathHash`
110 // from the incremental cache.
111 local_def_path_hash_to_def_id
: UnhashMap
<DefPathHash
, LocalDefId
>,
112 // Caches all lookups of `DefPathHashes`, both for local and foreign
113 // definitions. A definition from the previous compilation session
114 // may no longer exist in the current compilation session, so
115 // we use `Option<DefId>` so that we can cache a lookup failure.
116 def_path_hash_to_def_id_cache
: Lock
<UnhashMap
<DefPathHash
, Option
<DefId
>>>,
119 // This type is used only for serialization and deserialization.
120 #[derive(Encodable, Decodable)]
122 file_index_to_stable_id
: FxHashMap
<SourceFileIndex
, StableSourceFileId
>,
123 prev_cnums
: Vec
<(u32, String
, CrateDisambiguator
)>,
124 query_result_index
: EncodedQueryResultIndex
,
125 diagnostics_index
: EncodedQueryResultIndex
,
126 // The location of all allocations.
127 interpret_alloc_index
: Vec
<u32>,
128 // See `OnDiskCache.syntax_contexts`
129 syntax_contexts
: FxHashMap
<u32, AbsoluteBytePos
>,
130 // See `OnDiskCache.expn_data`
131 expn_data
: FxHashMap
<u32, AbsoluteBytePos
>,
132 foreign_def_path_hashes
: UnhashMap
<DefPathHash
, RawDefId
>,
135 type EncodedQueryResultIndex
= Vec
<(SerializedDepNodeIndex
, AbsoluteBytePos
)>;
136 type EncodedDiagnosticsIndex
= Vec
<(SerializedDepNodeIndex
, AbsoluteBytePos
)>;
137 type EncodedDiagnostics
= Vec
<Diagnostic
>;
139 #[derive(Copy, Clone, PartialEq, Eq, Hash, Debug, Encodable, Decodable)]
140 struct SourceFileIndex(u32);
142 #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Encodable, Decodable)]
143 struct AbsoluteBytePos(u32);
145 impl AbsoluteBytePos
{
146 fn new(pos
: usize) -> AbsoluteBytePos
{
147 debug_assert
!(pos
<= u32::MAX
as usize);
148 AbsoluteBytePos(pos
as u32)
151 fn to_usize(self) -> usize {
156 /// Represents a potentially invalid `DefId`. This is used during incremental
157 /// compilation to represent a `DefId` from the *previous* compilation session,
158 /// which may no longer be valid. This is used to help map a `DefPathHash`
159 /// to a `DefId` in the current compilation session.
160 #[derive(Encodable, Decodable, Copy, Clone, Debug)]
161 crate struct RawDefId
{
162 // We deliberately do not use `CrateNum` and `DefIndex`
163 // here, since a crate/index from the previous compilation
164 // session may no longer exist.
169 fn make_local_def_path_hash_map(definitions
: &Definitions
) -> UnhashMap
<DefPathHash
, LocalDefId
> {
170 UnhashMap
::from_iter(
173 .all_def_path_hashes_and_def_ids(LOCAL_CRATE
)
174 .map(|(hash
, def_id
)| (hash
, def_id
.as_local().unwrap())),
178 impl<'sess
> OnDiskCache
<'sess
> {
179 /// Creates a new `OnDiskCache` instance from the serialized data in `data`.
181 sess
: &'sess Session
,
184 definitions
: &Definitions
,
186 debug_assert
!(sess
.opts
.incremental
.is_some());
188 // Wrap in a scope so we can borrow `data`.
189 let footer
: Footer
= {
190 let mut decoder
= opaque
::Decoder
::new(&data
[..], start_pos
);
192 // Decode the *position* of the footer, which can be found in the
193 // last 8 bytes of the file.
194 decoder
.set_position(data
.len() - IntEncodedWithFixedSize
::ENCODED_SIZE
);
195 let footer_pos
= IntEncodedWithFixedSize
::decode(&mut decoder
)
196 .expect("error while trying to decode footer position")
199 // Decode the file footer, which contains all the lookup tables, etc.
200 decoder
.set_position(footer_pos
);
202 decode_tagged(&mut decoder
, TAG_FILE_FOOTER
)
203 .expect("error while trying to decode footer position")
207 serialized_data
: data
,
208 file_index_to_stable_id
: footer
.file_index_to_stable_id
,
209 file_index_to_file
: Default
::default(),
210 prev_cnums
: footer
.prev_cnums
,
211 cnum_map
: OnceCell
::new(),
212 source_map
: sess
.source_map(),
213 current_diagnostics
: Default
::default(),
214 query_result_index
: footer
.query_result_index
.into_iter().collect(),
215 prev_diagnostics_index
: footer
.diagnostics_index
.into_iter().collect(),
216 alloc_decoding_state
: AllocDecodingState
::new(footer
.interpret_alloc_index
),
217 syntax_contexts
: footer
.syntax_contexts
,
218 expn_data
: footer
.expn_data
,
219 hygiene_context
: Default
::default(),
220 foreign_def_path_hashes
: footer
.foreign_def_path_hashes
,
221 latest_foreign_def_path_hashes
: Default
::default(),
222 local_def_path_hash_to_def_id
: make_local_def_path_hash_map(definitions
),
223 def_path_hash_to_def_id_cache
: Default
::default(),
227 pub fn new_empty(source_map
: &'sess SourceMap
) -> Self {
229 serialized_data
: Vec
::new(),
230 file_index_to_stable_id
: Default
::default(),
231 file_index_to_file
: Default
::default(),
233 cnum_map
: OnceCell
::new(),
235 current_diagnostics
: Default
::default(),
236 query_result_index
: Default
::default(),
237 prev_diagnostics_index
: Default
::default(),
238 alloc_decoding_state
: AllocDecodingState
::new(Vec
::new()),
239 syntax_contexts
: FxHashMap
::default(),
240 expn_data
: FxHashMap
::default(),
241 hygiene_context
: Default
::default(),
242 foreign_def_path_hashes
: Default
::default(),
243 latest_foreign_def_path_hashes
: Default
::default(),
244 local_def_path_hash_to_def_id
: Default
::default(),
245 def_path_hash_to_def_id_cache
: Default
::default(),
249 pub fn serialize
<'tcx
>(
252 encoder
: &mut FileEncoder
,
253 ) -> FileEncodeResult
{
254 // Serializing the `DepGraph` should not modify it.
255 tcx
.dep_graph
.with_ignore(|| {
256 // Allocate `SourceFileIndex`es.
257 let (file_to_file_index
, file_index_to_stable_id
) = {
258 let files
= tcx
.sess
.source_map().files();
259 let mut file_to_file_index
=
260 FxHashMap
::with_capacity_and_hasher(files
.len(), Default
::default());
261 let mut file_index_to_stable_id
=
262 FxHashMap
::with_capacity_and_hasher(files
.len(), Default
::default());
264 for (index
, file
) in files
.iter().enumerate() {
265 let index
= SourceFileIndex(index
as u32);
266 let file_ptr
: *const SourceFile
= &**file
as *const _
;
267 file_to_file_index
.insert(file_ptr
, index
);
268 file_index_to_stable_id
.insert(index
, StableSourceFileId
::new(&file
));
271 (file_to_file_index
, file_index_to_stable_id
)
274 // Register any dep nodes that we reused from the previous session,
275 // but didn't `DepNode::construct` in this session. This ensures
276 // that their `DefPathHash` to `RawDefId` mappings are registered
277 // in 'latest_foreign_def_path_hashes' if necessary, since that
278 // normally happens in `DepNode::construct`.
279 tcx
.dep_graph
.register_reused_dep_nodes(tcx
);
281 // Load everything into memory so we can write it out to the on-disk
282 // cache. The vast majority of cacheable query results should already
283 // be in memory, so this should be a cheap operation.
284 // Do this *before* we clone 'latest_foreign_def_path_hashes', since
285 // loading existing queries may cause us to create new DepNodes, which
286 // may in turn end up invoking `store_foreign_def_id_hash`
287 tcx
.dep_graph
.exec_cache_promotions(tcx
);
289 let latest_foreign_def_path_hashes
= self.latest_foreign_def_path_hashes
.lock().clone();
290 let hygiene_encode_context
= HygieneEncodeContext
::default();
292 let mut encoder
= CacheEncoder
{
295 type_shorthands
: Default
::default(),
296 predicate_shorthands
: Default
::default(),
297 interpret_allocs
: Default
::default(),
298 source_map
: CachingSourceMapView
::new(tcx
.sess
.source_map()),
300 hygiene_context
: &hygiene_encode_context
,
301 latest_foreign_def_path_hashes
,
304 // Encode query results.
305 let mut query_result_index
= EncodedQueryResultIndex
::new();
307 tcx
.sess
.time("encode_query_results", || -> FileEncodeResult
{
308 let enc
= &mut encoder
;
309 let qri
= &mut query_result_index
;
311 macro_rules
! encode_queries
{
312 ($
($query
:ident
,)*) => {
314 encode_query_results
::<ty
::query
::queries
::$query
<'_
>>(
323 rustc_cached_queries
!(encode_queries
!);
328 // Encode diagnostics.
329 let diagnostics_index
: EncodedDiagnosticsIndex
= self
334 |(dep_node_index
, diagnostics
)| -> Result
<_
, <FileEncoder
as Encoder
>::Error
> {
335 let pos
= AbsoluteBytePos
::new(encoder
.position());
336 // Let's make sure we get the expected type here.
337 let diagnostics
: &EncodedDiagnostics
= diagnostics
;
338 let dep_node_index
= SerializedDepNodeIndex
::new(dep_node_index
.index());
339 encoder
.encode_tagged(dep_node_index
, diagnostics
)?
;
341 Ok((dep_node_index
, pos
))
344 .collect
::<Result
<_
, _
>>()?
;
346 let interpret_alloc_index
= {
347 let mut interpret_alloc_index
= Vec
::new();
350 let new_n
= encoder
.interpret_allocs
.len();
351 // If we have found new IDs, serialize those too.
356 interpret_alloc_index
.reserve(new_n
- n
);
357 for idx
in n
..new_n
{
358 let id
= encoder
.interpret_allocs
[idx
];
359 let pos
= encoder
.position() as u32;
360 interpret_alloc_index
.push(pos
);
361 interpret
::specialized_encode_alloc_id(&mut encoder
, tcx
, id
)?
;
365 interpret_alloc_index
368 let sorted_cnums
= sorted_cnums_including_local_crate(tcx
);
369 let prev_cnums
: Vec
<_
> = sorted_cnums
372 let crate_name
= tcx
.original_crate_name(cnum
).to_string();
373 let crate_disambiguator
= tcx
.crate_disambiguator(cnum
);
374 (cnum
.as_u32(), crate_name
, crate_disambiguator
)
378 let mut syntax_contexts
= FxHashMap
::default();
379 let mut expn_ids
= FxHashMap
::default();
381 // Encode all hygiene data (`SyntaxContextData` and `ExpnData`) from the current
384 hygiene_encode_context
.encode(
386 |encoder
, index
, ctxt_data
| -> FileEncodeResult
{
387 let pos
= AbsoluteBytePos
::new(encoder
.position());
388 encoder
.encode_tagged(TAG_SYNTAX_CONTEXT
, ctxt_data
)?
;
389 syntax_contexts
.insert(index
, pos
);
392 |encoder
, index
, expn_data
| -> FileEncodeResult
{
393 let pos
= AbsoluteBytePos
::new(encoder
.position());
394 encoder
.encode_tagged(TAG_EXPN_DATA
, expn_data
)?
;
395 expn_ids
.insert(index
, pos
);
400 let foreign_def_path_hashes
=
401 std
::mem
::take(&mut encoder
.latest_foreign_def_path_hashes
);
403 // `Encode the file footer.
404 let footer_pos
= encoder
.position() as u64;
405 encoder
.encode_tagged(
408 file_index_to_stable_id
,
412 interpret_alloc_index
,
415 foreign_def_path_hashes
,
419 // Encode the position of the footer as the last 8 bytes of the
420 // file so we know where to look for it.
421 IntEncodedWithFixedSize(footer_pos
).encode(encoder
.encoder
)?
;
423 // DO NOT WRITE ANYTHING TO THE ENCODER AFTER THIS POINT! The address
424 // of the footer must be the last thing in the data stream.
428 fn sorted_cnums_including_local_crate(tcx
: TyCtxt
<'_
>) -> Vec
<CrateNum
> {
429 let mut cnums
= vec
![LOCAL_CRATE
];
430 cnums
.extend_from_slice(&tcx
.crates()[..]);
431 cnums
.sort_unstable();
432 // Just to be sure...
439 /// Loads a diagnostic emitted during the previous compilation session.
440 pub fn load_diagnostics(
443 dep_node_index
: SerializedDepNodeIndex
,
444 ) -> Vec
<Diagnostic
> {
445 let diagnostics
: Option
<EncodedDiagnostics
> =
446 self.load_indexed(tcx
, dep_node_index
, &self.prev_diagnostics_index
, "diagnostics");
448 diagnostics
.unwrap_or_default()
451 /// Stores a diagnostic emitted during the current compilation session.
452 /// Anything stored like this will be available via `load_diagnostics` in
453 /// the next compilation session.
456 pub fn store_diagnostics(
458 dep_node_index
: DepNodeIndex
,
459 diagnostics
: ThinVec
<Diagnostic
>,
461 let mut current_diagnostics
= self.current_diagnostics
.borrow_mut();
462 let prev
= current_diagnostics
.insert(dep_node_index
, diagnostics
.into());
463 debug_assert
!(prev
.is_none());
466 fn get_raw_def_id(&self, hash
: &DefPathHash
) -> Option
<RawDefId
> {
467 self.foreign_def_path_hashes
.get(hash
).copied()
470 fn try_remap_cnum(&self, tcx
: TyCtxt
<'_
>, cnum
: u32) -> Option
<CrateNum
> {
472 self.cnum_map
.get_or_init(|| Self::compute_cnum_map(tcx
, &self.prev_cnums
[..]));
473 debug
!("try_remap_cnum({}): cnum_map={:?}", cnum
, cnum_map
);
475 cnum_map
[CrateNum
::from_u32(cnum
)]
478 pub(crate) fn store_foreign_def_id_hash(&self, def_id
: DefId
, hash
: DefPathHash
) {
479 // We may overwrite an existing entry, but it will have the same value,
481 self.latest_foreign_def_path_hashes
483 .insert(hash
, RawDefId { krate: def_id.krate.as_u32(), index: def_id.index.as_u32() }
);
486 /// If the given `dep_node`'s hash still exists in the current compilation,
487 /// and its current `DefId` is foreign, calls `store_foreign_def_id` with it.
489 /// Normally, `store_foreign_def_id_hash` can be called directly by
490 /// the dependency graph when we construct a `DepNode`. However,
491 /// when we re-use a deserialized `DepNode` from the previous compilation
492 /// session, we only have the `DefPathHash` available. This method is used
493 /// to that any `DepNode` that we re-use has a `DefPathHash` -> `RawId` written
494 /// out for usage in the next compilation session.
495 pub fn register_reused_dep_node(&self, tcx
: TyCtxt
<'tcx
>, dep_node
: &DepNode
) {
496 // For reused dep nodes, we only need to store the mapping if the node
497 // is one whose query key we can reconstruct from the hash. We use the
498 // mapping to aid that reconstruction in the next session. While we also
499 // use it to decode `DefId`s we encoded in the cache as `DefPathHashes`,
500 // they're already registered during `DefId` encoding.
501 if dep_node
.kind
.can_reconstruct_query_key() {
502 let hash
= DefPathHash(dep_node
.hash
.into());
504 // We can't simply copy the `RawDefId` from `foreign_def_path_hashes` to
505 // `latest_foreign_def_path_hashes`, since the `RawDefId` might have
506 // changed in the current compilation session (e.g. we've added/removed crates,
507 // or added/removed definitions before/after the target definition).
508 if let Some(def_id
) = self.def_path_hash_to_def_id(tcx
, hash
) {
509 if !def_id
.is_local() {
510 self.store_foreign_def_id_hash(def_id
, hash
);
516 /// Returns the cached query result if there is something in the cache for
517 /// the given `SerializedDepNodeIndex`; otherwise returns `None`.
518 crate fn try_load_query_result
<'tcx
, T
>(
521 dep_node_index
: SerializedDepNodeIndex
,
524 T
: for<'a
> Decodable
<CacheDecoder
<'a
, 'tcx
>>,
526 self.load_indexed(tcx
, dep_node_index
, &self.query_result_index
, "query result")
529 /// Stores a diagnostic emitted during computation of an anonymous query.
530 /// Since many anonymous queries can share the same `DepNode`, we aggregate
531 /// them -- as opposed to regular queries where we assume that there is a
532 /// 1:1 relationship between query-key and `DepNode`.
535 pub fn store_diagnostics_for_anon_node(
537 dep_node_index
: DepNodeIndex
,
538 diagnostics
: ThinVec
<Diagnostic
>,
540 let mut current_diagnostics
= self.current_diagnostics
.borrow_mut();
542 let x
= current_diagnostics
.entry(dep_node_index
).or_insert(Vec
::new());
544 x
.extend(Into
::<Vec
<_
>>::into(diagnostics
));
547 fn load_indexed
<'tcx
, T
>(
550 dep_node_index
: SerializedDepNodeIndex
,
551 index
: &FxHashMap
<SerializedDepNodeIndex
, AbsoluteBytePos
>,
552 debug_tag
: &'
static str,
555 T
: for<'a
> Decodable
<CacheDecoder
<'a
, 'tcx
>>,
557 let pos
= index
.get(&dep_node_index
).cloned()?
;
559 self.with_decoder(tcx
, pos
, |decoder
| match decode_tagged(decoder
, dep_node_index
) {
561 Err(e
) => bug
!("could not decode cached {}: {}", debug_tag
, e
),
565 fn with_decoder
<'a
, 'tcx
, T
, F
: FnOnce(&mut CacheDecoder
<'sess
, 'tcx
>) -> T
>(
568 pos
: AbsoluteBytePos
,
572 T
: Decodable
<CacheDecoder
<'a
, 'tcx
>>,
575 self.cnum_map
.get_or_init(|| Self::compute_cnum_map(tcx
, &self.prev_cnums
[..]));
577 let mut decoder
= CacheDecoder
{
579 opaque
: opaque
::Decoder
::new(&self.serialized_data
[..], pos
.to_usize()),
580 source_map
: self.source_map
,
582 file_index_to_file
: &self.file_index_to_file
,
583 file_index_to_stable_id
: &self.file_index_to_stable_id
,
584 alloc_decoding_session
: self.alloc_decoding_state
.new_decoding_session(),
585 syntax_contexts
: &self.syntax_contexts
,
586 expn_data
: &self.expn_data
,
587 hygiene_context
: &self.hygiene_context
,
592 // This function builds mapping from previous-session-`CrateNum` to
593 // current-session-`CrateNum`. There might be `CrateNum`s from the previous
594 // `Session` that don't occur in the current one. For these, the mapping
598 prev_cnums
: &[(u32, String
, CrateDisambiguator
)],
599 ) -> IndexVec
<CrateNum
, Option
<CrateNum
>> {
600 tcx
.dep_graph
.with_ignore(|| {
601 let current_cnums
= tcx
602 .all_crate_nums(LOCAL_CRATE
)
605 let crate_name
= tcx
.original_crate_name(cnum
).to_string();
606 let crate_disambiguator
= tcx
.crate_disambiguator(cnum
);
607 ((crate_name
, crate_disambiguator
), cnum
)
609 .collect
::<FxHashMap
<_
, _
>>();
611 let map_size
= prev_cnums
.iter().map(|&(cnum
, ..)| cnum
).max().unwrap_or(0) + 1;
612 let mut map
= IndexVec
::from_elem_n(None
, map_size
as usize);
614 for &(prev_cnum
, ref crate_name
, crate_disambiguator
) in prev_cnums
{
615 let key
= (crate_name
.clone(), crate_disambiguator
);
616 map
[CrateNum
::from_u32(prev_cnum
)] = current_cnums
.get(&key
).cloned();
619 map
[LOCAL_CRATE
] = Some(LOCAL_CRATE
);
624 /// Converts a `DefPathHash` to its corresponding `DefId` in the current compilation
625 /// session, if it still exists. This is used during incremental compilation to
626 /// turn a deserialized `DefPathHash` into its current `DefId`.
627 pub(crate) fn def_path_hash_to_def_id(
632 let mut cache
= self.def_path_hash_to_def_id_cache
.lock();
633 match cache
.entry(hash
) {
634 Entry
::Occupied(e
) => *e
.get(),
635 Entry
::Vacant(e
) => {
636 debug
!("def_path_hash_to_def_id({:?})", hash
);
637 // Check if the `DefPathHash` corresponds to a definition in the current
639 if let Some(def_id
) = self.local_def_path_hash_to_def_id
.get(&hash
).cloned() {
640 let def_id
= def_id
.to_def_id();
641 e
.insert(Some(def_id
));
644 // This `raw_def_id` represents the `DefId` of this `DefPathHash` in
645 // the *previous* compliation session. The `DefPathHash` includes the
646 // owning crate, so if the corresponding definition still exists in the
647 // current compilation session, the crate is guaranteed to be the same
648 // (otherwise, we would compute a different `DefPathHash`).
649 let raw_def_id
= self.get_raw_def_id(&hash
)?
;
650 debug
!("def_path_hash_to_def_id({:?}): raw_def_id = {:?}", hash
, raw_def_id
);
651 // If the owning crate no longer exists, the corresponding definition definitely
653 let krate
= self.try_remap_cnum(tcx
, raw_def_id
.krate
)?
;
654 debug
!("def_path_hash_to_def_id({:?}): krate = {:?}", hash
, krate
);
655 // If our `DefPathHash` corresponded to a definition in the local crate,
656 // we should have either found it in `local_def_path_hash_to_def_id`, or
657 // never attempted to load it in the first place. Any query result or `DepNode`
658 // that references a local `DefId` should depend on some HIR-related `DepNode`.
659 // If a local definition is removed/modified such that its old `DefPathHash`
660 // no longer has a corresponding definition, that HIR-related `DepNode` should
661 // end up red. This should prevent us from ever calling
662 // `tcx.def_path_hash_to_def_id`, since we'll end up recomputing any
664 debug_assert_ne
!(krate
, LOCAL_CRATE
);
665 // Try to find a definition in the current session, using the previous `DefIndex`
666 // as an initial guess.
667 let opt_def_id
= tcx
.cstore
.def_path_hash_to_def_id(krate
, raw_def_id
.index
, hash
);
668 debug
!("def_path_to_def_id({:?}): opt_def_id = {:?}", hash
, opt_def_id
);
669 e
.insert(opt_def_id
);
676 //- DECODING -------------------------------------------------------------------
678 /// A decoder that can read from the incremental compilation cache. It is similar to the one
679 /// we use for crate metadata decoding in that it can rebase spans and eventually
680 /// will also handle things that contain `Ty` instances.
681 crate struct CacheDecoder
<'a
, 'tcx
> {
683 opaque
: opaque
::Decoder
<'a
>,
684 source_map
: &'a SourceMap
,
685 cnum_map
: &'a IndexVec
<CrateNum
, Option
<CrateNum
>>,
686 file_index_to_file
: &'a Lock
<FxHashMap
<SourceFileIndex
, Lrc
<SourceFile
>>>,
687 file_index_to_stable_id
: &'a FxHashMap
<SourceFileIndex
, StableSourceFileId
>,
688 alloc_decoding_session
: AllocDecodingSession
<'a
>,
689 syntax_contexts
: &'a FxHashMap
<u32, AbsoluteBytePos
>,
690 expn_data
: &'a FxHashMap
<u32, AbsoluteBytePos
>,
691 hygiene_context
: &'a HygieneDecodeContext
,
694 impl<'a
, 'tcx
> CacheDecoder
<'a
, 'tcx
> {
695 fn file_index_to_file(&self, index
: SourceFileIndex
) -> Lrc
<SourceFile
> {
697 ref file_index_to_file
,
698 ref file_index_to_stable_id
,
707 let stable_id
= file_index_to_stable_id
[&index
];
709 .source_file_by_stable_id(stable_id
)
710 .expect("failed to lookup `SourceFile` in new context")
716 trait DecoderWithPosition
: Decoder
{
717 fn position(&self) -> usize;
720 impl<'a
> DecoderWithPosition
for opaque
::Decoder
<'a
> {
721 fn position(&self) -> usize {
726 impl<'a
, 'tcx
> DecoderWithPosition
for CacheDecoder
<'a
, 'tcx
> {
727 fn position(&self) -> usize {
728 self.opaque
.position()
732 // Decodes something that was encoded with `encode_tagged()` and verify that the
733 // tag matches and the correct amount of bytes was read.
734 fn decode_tagged
<D
, T
, V
>(decoder
: &mut D
, expected_tag
: T
) -> Result
<V
, D
::Error
>
736 T
: Decodable
<D
> + Eq
+ std
::fmt
::Debug
,
738 D
: DecoderWithPosition
,
740 let start_pos
= decoder
.position();
742 let actual_tag
= T
::decode(decoder
)?
;
743 assert_eq
!(actual_tag
, expected_tag
);
744 let value
= V
::decode(decoder
)?
;
745 let end_pos
= decoder
.position();
747 let expected_len
: u64 = Decodable
::decode(decoder
)?
;
748 assert_eq
!((end_pos
- start_pos
) as u64, expected_len
);
753 impl<'a
, 'tcx
> TyDecoder
<'tcx
> for CacheDecoder
<'a
, 'tcx
> {
754 const CLEAR_CROSS_CRATE
: bool
= false;
757 fn tcx(&self) -> TyCtxt
<'tcx
> {
762 fn position(&self) -> usize {
763 self.opaque
.position()
767 fn peek_byte(&self) -> u8 {
768 self.opaque
.data
[self.opaque
.position()]
771 fn cached_ty_for_shorthand
<F
>(
775 ) -> Result
<Ty
<'tcx
>, Self::Error
>
777 F
: FnOnce(&mut Self) -> Result
<Ty
<'tcx
>, Self::Error
>,
779 let tcx
= self.tcx();
782 ty
::CReaderCacheKey { cnum: CrateNum::ReservedForIncrCompCache, pos: shorthand }
;
784 if let Some(&ty
) = tcx
.ty_rcache
.borrow().get(&cache_key
) {
788 let ty
= or_insert_with(self)?
;
789 // This may overwrite the entry, but it should overwrite with the same value.
790 tcx
.ty_rcache
.borrow_mut().insert_same(cache_key
, ty
);
794 fn with_position
<F
, R
>(&mut self, pos
: usize, f
: F
) -> R
796 F
: FnOnce(&mut Self) -> R
,
798 debug_assert
!(pos
< self.opaque
.data
.len());
800 let new_opaque
= opaque
::Decoder
::new(self.opaque
.data
, pos
);
801 let old_opaque
= mem
::replace(&mut self.opaque
, new_opaque
);
803 self.opaque
= old_opaque
;
807 fn map_encoded_cnum_to_current(&self, cnum
: CrateNum
) -> CrateNum
{
808 self.cnum_map
[cnum
].unwrap_or_else(|| bug
!("could not find new `CrateNum` for {:?}", cnum
))
811 fn decode_alloc_id(&mut self) -> Result
<interpret
::AllocId
, Self::Error
> {
812 let alloc_decoding_session
= self.alloc_decoding_session
;
813 alloc_decoding_session
.decode_alloc_id(self)
817 crate::implement_ty_decoder
!(CacheDecoder
<'a
, 'tcx
>);
819 // This ensures that the `Decodable<opaque::Decoder>::decode` specialization for `Vec<u8>` is used
820 // when a `CacheDecoder` is passed to `Decodable::decode`. Unfortunately, we have to manually opt
821 // into specializations this way, given how `CacheDecoder` and the decoding traits currently work.
822 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for Vec
<u8> {
823 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
824 Decodable
::decode(&mut d
.opaque
)
828 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for SyntaxContext
{
829 fn decode(decoder
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
830 let syntax_contexts
= decoder
.syntax_contexts
;
831 rustc_span
::hygiene
::decode_syntax_context(decoder
, decoder
.hygiene_context
, |this
, id
| {
832 // This closure is invoked if we haven't already decoded the data for the `SyntaxContext` we are deserializing.
833 // We look up the position of the associated `SyntaxData` and decode it.
834 let pos
= syntax_contexts
.get(&id
).unwrap();
835 this
.with_position(pos
.to_usize(), |decoder
| {
836 let data
: SyntaxContextData
= decode_tagged(decoder
, TAG_SYNTAX_CONTEXT
)?
;
843 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for ExpnId
{
844 fn decode(decoder
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
845 let expn_data
= decoder
.expn_data
;
846 rustc_span
::hygiene
::decode_expn_id(
848 ExpnDataDecodeMode
::incr_comp(decoder
.hygiene_context
),
850 // This closure is invoked if we haven't already decoded the data for the `ExpnId` we are deserializing.
851 // We look up the position of the associated `ExpnData` and decode it.
854 .unwrap_or_else(|| panic
!("Bad index {:?} (map {:?})", index
, expn_data
));
856 this
.with_position(pos
.to_usize(), |decoder
| {
857 let data
: ExpnData
= decode_tagged(decoder
, TAG_EXPN_DATA
)?
;
865 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for Span
{
866 fn decode(decoder
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
867 let tag
: u8 = Decodable
::decode(decoder
)?
;
869 if tag
== TAG_PARTIAL_SPAN
{
870 let ctxt
= SyntaxContext
::decode(decoder
)?
;
871 return Ok(DUMMY_SP
.with_ctxt(ctxt
));
873 debug_assert_eq
!(tag
, TAG_FULL_SPAN
);
876 let file_lo_index
= SourceFileIndex
::decode(decoder
)?
;
877 let line_lo
= usize::decode(decoder
)?
;
878 let col_lo
= BytePos
::decode(decoder
)?
;
879 let len
= BytePos
::decode(decoder
)?
;
880 let ctxt
= SyntaxContext
::decode(decoder
)?
;
882 let file_lo
= decoder
.file_index_to_file(file_lo_index
);
883 let lo
= file_lo
.lines
[line_lo
- 1] + col_lo
;
886 Ok(Span
::new(lo
, hi
, ctxt
))
890 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for CrateNum
{
891 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
892 let cnum
= CrateNum
::from_u32(u32::decode(d
)?
);
893 Ok(d
.map_encoded_cnum_to_current(cnum
))
897 // This impl makes sure that we get a runtime error when we try decode a
898 // `DefIndex` that is not contained in a `DefId`. Such a case would be problematic
899 // because we would not know how to transform the `DefIndex` to the current
901 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for DefIndex
{
902 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<DefIndex
, String
> {
903 Err(d
.error("trying to decode `DefIndex` outside the context of a `DefId`"))
907 // Both the `CrateNum` and the `DefIndex` of a `DefId` can change in between two
908 // compilation sessions. We use the `DefPathHash`, which is stable across
909 // sessions, to map the old `DefId` to the new one.
910 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for DefId
{
911 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
912 // Load the `DefPathHash` which is was we encoded the `DefId` as.
913 let def_path_hash
= DefPathHash
::decode(d
)?
;
915 // Using the `DefPathHash`, we can lookup the new `DefId`.
916 // Subtle: We only encode a `DefId` as part of a query result.
917 // If we get to this point, then all of the query inputs were green,
918 // which means that the definition with this hash is guaranteed to
919 // still exist in the current compilation session.
925 .def_path_hash_to_def_id(d
.tcx(), def_path_hash
)
930 impl<'a
, 'tcx
> FingerprintDecoder
for CacheDecoder
<'a
, 'tcx
> {
931 fn decode_fingerprint(&mut self) -> Result
<Fingerprint
, Self::Error
> {
932 Fingerprint
::decode_opaque(&mut self.opaque
)
936 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx FxHashSet
<LocalDefId
> {
937 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
938 RefDecodable
::decode(d
)
942 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>>
943 for &'tcx IndexVec
<mir
::Promoted
, mir
::Body
<'tcx
>>
945 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
946 RefDecodable
::decode(d
)
950 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[mir
::abstract_const
::Node
<'tcx
>] {
951 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
952 RefDecodable
::decode(d
)
956 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[(ty
::Predicate
<'tcx
>, Span
)] {
957 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
958 RefDecodable
::decode(d
)
962 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[rustc_ast
::InlineAsmTemplatePiece
] {
963 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
964 RefDecodable
::decode(d
)
968 impl<'a
, 'tcx
> Decodable
<CacheDecoder
<'a
, 'tcx
>> for &'tcx
[Span
] {
969 fn decode(d
: &mut CacheDecoder
<'a
, 'tcx
>) -> Result
<Self, String
> {
970 RefDecodable
::decode(d
)
974 //- ENCODING -------------------------------------------------------------------
976 trait OpaqueEncoder
: Encoder
{
977 fn position(&self) -> usize;
980 impl OpaqueEncoder
for FileEncoder
{
982 fn position(&self) -> usize {
983 FileEncoder
::position(self)
987 /// An encoder that can write to the incremental compilation cache.
988 struct CacheEncoder
<'a
, 'tcx
, E
: OpaqueEncoder
> {
991 type_shorthands
: FxHashMap
<Ty
<'tcx
>, usize>,
992 predicate_shorthands
: FxHashMap
<ty
::PredicateKind
<'tcx
>, usize>,
993 interpret_allocs
: FxIndexSet
<interpret
::AllocId
>,
994 source_map
: CachingSourceMapView
<'tcx
>,
995 file_to_file_index
: FxHashMap
<*const SourceFile
, SourceFileIndex
>,
996 hygiene_context
: &'a HygieneEncodeContext
,
997 latest_foreign_def_path_hashes
: UnhashMap
<DefPathHash
, RawDefId
>,
1000 impl<'a
, 'tcx
, E
> CacheEncoder
<'a
, 'tcx
, E
>
1002 E
: 'a
+ OpaqueEncoder
,
1004 fn source_file_index(&mut self, source_file
: Lrc
<SourceFile
>) -> SourceFileIndex
{
1005 self.file_to_file_index
[&(&*source_file
as *const SourceFile
)]
1008 /// Encode something with additional information that allows to do some
1009 /// sanity checks when decoding the data again. This method will first
1010 /// encode the specified tag, then the given value, then the number of
1011 /// bytes taken up by tag and value. On decoding, we can then verify that
1012 /// we get the expected tag and read the expected number of bytes.
1013 fn encode_tagged
<T
: Encodable
<Self>, V
: Encodable
<Self>>(
1017 ) -> Result
<(), E
::Error
> {
1018 let start_pos
= self.position();
1021 value
.encode(self)?
;
1023 let end_pos
= self.position();
1024 ((end_pos
- start_pos
) as u64).encode(self)
1028 impl<'a
, 'tcx
, E
: OpaqueEncoder
> FingerprintEncoder
for CacheEncoder
<'a
, 'tcx
, E
> {
1029 fn encode_fingerprint(&mut self, f
: &Fingerprint
) -> Result
<(), E
::Error
> {
1030 self.encoder
.encode_fingerprint(f
)
1034 impl<'a
, 'tcx
, E
> Encodable
<CacheEncoder
<'a
, 'tcx
, E
>> for SyntaxContext
1036 E
: 'a
+ OpaqueEncoder
,
1038 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
, E
>) -> Result
<(), E
::Error
> {
1039 rustc_span
::hygiene
::raw_encode_syntax_context(*self, s
.hygiene_context
, s
)
1043 impl<'a
, 'tcx
, E
> Encodable
<CacheEncoder
<'a
, 'tcx
, E
>> for ExpnId
1045 E
: 'a
+ OpaqueEncoder
,
1047 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
, E
>) -> Result
<(), E
::Error
> {
1048 rustc_span
::hygiene
::raw_encode_expn_id(
1051 ExpnDataEncodeMode
::IncrComp
,
1057 impl<'a
, 'tcx
, E
> Encodable
<CacheEncoder
<'a
, 'tcx
, E
>> for Span
1059 E
: 'a
+ OpaqueEncoder
,
1061 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
, E
>) -> Result
<(), E
::Error
> {
1062 if *self == DUMMY_SP
{
1063 TAG_PARTIAL_SPAN
.encode(s
)?
;
1064 return SyntaxContext
::root().encode(s
);
1067 let span_data
= self.data();
1068 let pos
= s
.source_map
.byte_pos_to_line_and_col(span_data
.lo
);
1069 let partial_span
= match &pos
{
1070 Some((file_lo
, _
, _
)) => !file_lo
.contains(span_data
.hi
),
1075 TAG_PARTIAL_SPAN
.encode(s
)?
;
1076 return span_data
.ctxt
.encode(s
);
1079 let (file_lo
, line_lo
, col_lo
) = pos
.unwrap();
1081 let len
= span_data
.hi
- span_data
.lo
;
1083 let source_file_index
= s
.source_file_index(file_lo
);
1085 TAG_FULL_SPAN
.encode(s
)?
;
1086 source_file_index
.encode(s
)?
;
1090 span_data
.ctxt
.encode(s
)
1094 impl<'a
, 'tcx
, E
> TyEncoder
<'tcx
> for CacheEncoder
<'a
, 'tcx
, E
>
1096 E
: 'a
+ OpaqueEncoder
,
1098 const CLEAR_CROSS_CRATE
: bool
= false;
1100 fn position(&self) -> usize {
1101 self.encoder
.position()
1103 fn type_shorthands(&mut self) -> &mut FxHashMap
<Ty
<'tcx
>, usize> {
1104 &mut self.type_shorthands
1106 fn predicate_shorthands(&mut self) -> &mut FxHashMap
<ty
::PredicateKind
<'tcx
>, usize> {
1107 &mut self.predicate_shorthands
1109 fn encode_alloc_id(&mut self, alloc_id
: &interpret
::AllocId
) -> Result
<(), Self::Error
> {
1110 let (index
, _
) = self.interpret_allocs
.insert_full(*alloc_id
);
1116 impl<'a
, 'tcx
, E
> Encodable
<CacheEncoder
<'a
, 'tcx
, E
>> for DefId
1118 E
: 'a
+ OpaqueEncoder
,
1120 fn encode(&self, s
: &mut CacheEncoder
<'a
, 'tcx
, E
>) -> Result
<(), E
::Error
> {
1121 let def_path_hash
= s
.tcx
.def_path_hash(*self);
1122 // Store additional information when we encode a foreign `DefId`,
1123 // so that we can map its `DefPathHash` back to a `DefId` in the next
1124 // compilation session.
1125 if !self.is_local() {
1126 s
.latest_foreign_def_path_hashes
.insert(
1128 RawDefId { krate: self.krate.as_u32(), index: self.index.as_u32() }
,
1131 def_path_hash
.encode(s
)
1135 impl<'a
, 'tcx
, E
> Encodable
<CacheEncoder
<'a
, 'tcx
, E
>> for DefIndex
1137 E
: 'a
+ OpaqueEncoder
,
1139 fn encode(&self, _
: &mut CacheEncoder
<'a
, 'tcx
, E
>) -> Result
<(), E
::Error
> {
1140 bug
!("encoding `DefIndex` without context");
1144 macro_rules
! encoder_methods
{
1145 ($
($name
:ident($ty
:ty
);)*) => {
1147 $
(fn $
name(&mut self, value
: $ty
) -> Result
<(), Self::Error
> {
1148 self.encoder
.$
name(value
)
1153 impl<'a
, 'tcx
, E
> Encoder
for CacheEncoder
<'a
, 'tcx
, E
>
1155 E
: 'a
+ OpaqueEncoder
,
1157 type Error
= E
::Error
;
1160 fn emit_unit(&mut self) -> Result
<(), Self::Error
> {
1187 // This ensures that the `Encodable<opaque::FileEncoder>::encode` specialization for byte slices
1188 // is used when a `CacheEncoder` having an `opaque::FileEncoder` is passed to `Encodable::encode`.
1189 // Unfortunately, we have to manually opt into specializations this way, given how `CacheEncoder`
1190 // and the encoding traits currently work.
1191 impl<'a
, 'tcx
> Encodable
<CacheEncoder
<'a
, 'tcx
, FileEncoder
>> for [u8] {
1192 fn encode(&self, e
: &mut CacheEncoder
<'a
, 'tcx
, FileEncoder
>) -> FileEncodeResult
{
1193 self.encode(e
.encoder
)
1197 // An integer that will always encode to 8 bytes.
1198 struct IntEncodedWithFixedSize(u64);
1200 impl IntEncodedWithFixedSize
{
1201 pub const ENCODED_SIZE
: usize = 8;
1204 impl<E
: OpaqueEncoder
> Encodable
<E
> for IntEncodedWithFixedSize
{
1205 fn encode(&self, e
: &mut E
) -> Result
<(), E
::Error
> {
1206 let start_pos
= e
.position();
1207 for i
in 0..IntEncodedWithFixedSize
::ENCODED_SIZE
{
1208 ((self.0 >> (i
* 8)) as u8).encode(e
)?
;
1210 let end_pos
= e
.position();
1211 assert_eq
!((end_pos
- start_pos
), IntEncodedWithFixedSize
::ENCODED_SIZE
);
1216 impl<'a
> Decodable
<opaque
::Decoder
<'a
>> for IntEncodedWithFixedSize
{
1217 fn decode(decoder
: &mut opaque
::Decoder
<'a
>) -> Result
<IntEncodedWithFixedSize
, String
> {
1218 let mut value
: u64 = 0;
1219 let start_pos
= decoder
.position();
1221 for i
in 0..IntEncodedWithFixedSize
::ENCODED_SIZE
{
1222 let byte
: u8 = Decodable
::decode(decoder
)?
;
1223 value
|= (byte
as u64) << (i
* 8);
1226 let end_pos
= decoder
.position();
1227 assert_eq
!((end_pos
- start_pos
), IntEncodedWithFixedSize
::ENCODED_SIZE
);
1229 Ok(IntEncodedWithFixedSize(value
))
1233 fn encode_query_results
<'a
, 'tcx
, Q
>(
1235 encoder
: &mut CacheEncoder
<'a
, 'tcx
, FileEncoder
>,
1236 query_result_index
: &mut EncodedQueryResultIndex
,
1237 ) -> FileEncodeResult
1239 Q
: super::QueryDescription
<TyCtxt
<'tcx
>> + super::QueryAccessors
<TyCtxt
<'tcx
>>,
1240 Q
::Value
: Encodable
<CacheEncoder
<'a
, 'tcx
, FileEncoder
>>,
1245 .extra_verbose_generic_activity("encode_query_results_for", std
::any
::type_name
::<Q
>());
1247 let state
= Q
::query_state(tcx
);
1248 assert
!(state
.all_inactive());
1250 state
.iter_results(|results
| {
1251 for (key
, value
, dep_node
) in results
{
1252 if Q
::cache_on_disk(tcx
, &key
, Some(value
)) {
1253 let dep_node
= SerializedDepNodeIndex
::new(dep_node
.index());
1255 // Record position of the cache entry.
1257 .push((dep_node
, AbsoluteBytePos
::new(encoder
.encoder
.position())));
1259 // Encode the type check tables with the `SerializedDepNodeIndex`
1261 encoder
.encode_tagged(dep_node
, value
)?
;