less decoding if it has the same syntax context

Author: bvanjoi

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -471,10 +471,10 @@ impl<'a, 'tcx> SpanDecoder for DecodeContext<'a, 'tcx> {
 
         let cname = cdata.root.name();
         rustc_span::hygiene::decode_syntax_context(self, &cdata.hygiene_context, |_, id| {
-            debug!("SpecializedDecoder<SyntaxContext>: decoding {}", id);
+            debug!("SpecializedDecoder<SyntaxContextKey>: decoding {}", id);
             cdata
                 .root
-                .syntax_contexts
+                .syntax_context_keys
                 .get(cdata, id)
                 .unwrap_or_else(|| panic!("Missing SyntaxContext {id:?} for crate {cname:?}"))
                 .decode((cdata, sess))

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -684,7 +684,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         // the incremental cache. If this causes us to deserialize a `Span`, then we may load
         // additional `SyntaxContext`s into the global `HygieneData`. Therefore, we need to encode
         // the hygiene data last to ensure that we encode any `SyntaxContext`s that might be used.
-        let (syntax_contexts, expn_data, expn_hashes) = stat!("hygiene", || self.encode_hygiene());
+        let (syntax_context_keys, expn_data, expn_hashes) =
+            stat!("hygiene", || self.encode_hygiene());
 
         let def_path_hash_map = stat!("def-path-hash-map", || self.encode_def_path_hash_map());
 
@@ -742,7 +743,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
                 exported_symbols,
                 interpret_alloc_index,
                 tables,
-                syntax_contexts,
+                syntax_context_keys,
                 expn_data,
                 expn_hashes,
                 def_path_hash_map,
@@ -1852,15 +1853,15 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         self.lazy_array(foreign_modules.iter().map(|(_, m)| m).cloned())
     }
 
-    fn encode_hygiene(&mut self) -> (SyntaxContextTable, ExpnDataTable, ExpnHashTable) {
-        let mut syntax_contexts: TableBuilder<_, _> = Default::default();
+    fn encode_hygiene(&mut self) -> (SyntaxContextKeyTable, ExpnDataTable, ExpnHashTable) {
+        let mut syntax_context_keys: TableBuilder<_, _> = Default::default();
         let mut expn_data_table: TableBuilder<_, _> = Default::default();
         let mut expn_hash_table: TableBuilder<_, _> = Default::default();
 
         self.hygiene_ctxt.encode(
-            &mut (&mut *self, &mut syntax_contexts, &mut expn_data_table, &mut expn_hash_table),
-            |(this, syntax_contexts, _, _), index, ctxt_data| {
-                syntax_contexts.set_some(index, this.lazy(ctxt_data));
+            &mut (&mut *self, &mut syntax_context_keys, &mut expn_data_table, &mut expn_hash_table),
+            |(this, syntax_context_keys, _, _), index, ctxt_data| {
+                syntax_context_keys.set_some(index, this.lazy(ctxt_data));
             },
             |(this, _, expn_data_table, expn_hash_table), index, expn_data, hash| {
                 if let Some(index) = index.as_local() {
@@ -1871,7 +1872,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
         );
 
         (
-            syntax_contexts.encode(&mut self.opaque),
+            syntax_context_keys.encode(&mut self.opaque),
             expn_data_table.encode(&mut self.opaque),
             expn_hash_table.encode(&mut self.opaque),
         )

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -36,8 +36,9 @@ use rustc_serialize::opaque::FileEncoder;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
 use rustc_session::cstore::{CrateDepKind, ForeignModule, LinkagePreference, NativeLib};
 use rustc_span::edition::Edition;
-use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextData};
-use rustc_span::{self, ExpnData, ExpnHash, ExpnId, Ident, Span, Symbol};
+use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextKey};
+use rustc_span::symbol::{Ident, Symbol};
+use rustc_span::{self, ExpnData, ExpnHash, ExpnId, Span};
 use rustc_target::spec::{PanicStrategy, TargetTuple};
 use table::TableBuilder;
 use {rustc_ast as ast, rustc_attr_parsing as attr, rustc_hir as hir};
@@ -193,7 +194,7 @@ enum LazyState {
     Previous(NonZero<usize>),
 }
 
-type SyntaxContextTable = LazyTable<u32, Option<LazyValue<SyntaxContextData>>>;
+type SyntaxContextKeyTable = LazyTable<u32, Option<LazyValue<SyntaxContextKey>>>;
 type ExpnDataTable = LazyTable<ExpnIndex, Option<LazyValue<ExpnData>>>;
 type ExpnHashTable = LazyTable<ExpnIndex, Option<LazyValue<ExpnHash>>>;
 
@@ -276,7 +277,7 @@ pub(crate) struct CrateRoot {
 
     exported_symbols: LazyArray<(ExportedSymbol<'static>, SymbolExportInfo)>,
 
-    syntax_contexts: SyntaxContextTable,
+    syntax_context_keys: SyntaxContextKeyTable,
     expn_data: ExpnDataTable,
     expn_hashes: ExpnHashTable,
 

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -16,7 +16,7 @@ use rustc_serialize::opaque::{FileEncodeResult, FileEncoder, IntEncodedWithFixed
 use rustc_serialize::{Decodable, Decoder, Encodable, Encoder};
 use rustc_session::Session;
 use rustc_span::hygiene::{
-    ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextData,
+    ExpnId, HygieneDecodeContext, HygieneEncodeContext, SyntaxContext, SyntaxContextKey,
 };
 use rustc_span::source_map::Spanned;
 use rustc_span::{
@@ -39,7 +39,7 @@ const TAG_FULL_SPAN: u8 = 0;
 const TAG_PARTIAL_SPAN: u8 = 1;
 const TAG_RELATIVE_SPAN: u8 = 2;
 
-const TAG_SYNTAX_CONTEXT: u8 = 0;
+const TAG_SYNTAX_CONTEXT_KEY: u8 = 0;
 const TAG_EXPN_DATA: u8 = 1;
 
 // Tags for encoding Symbol's
@@ -79,7 +79,7 @@ pub struct OnDiskCache {
     // to represent the fact that we are storing *encoded* ids. When we decode
     // a `SyntaxContext`, a new id will be allocated from the global `HygieneData`,
     // which will almost certainly be different than the serialized id.
-    syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
+    syntax_context_keys: FxHashMap<u32, AbsoluteBytePos>,
     // A map from the `DefPathHash` of an `ExpnId` to the position
     // of their associated `ExpnData`. Ideally, we would store a `DefId`,
     // but we need to decode this before we've constructed a `TyCtxt` (which
@@ -110,7 +110,7 @@ struct Footer {
     // without measurable overhead. This permits larger const allocations without ICEing.
     interpret_alloc_index: Vec<u64>,
     // See `OnDiskCache.syntax_contexts`
-    syntax_contexts: FxHashMap<u32, AbsoluteBytePos>,
+    syntax_context_keys: FxHashMap<u32, AbsoluteBytePos>,
     // See `OnDiskCache.expn_data`
     expn_data: UnhashMap<ExpnHash, AbsoluteBytePos>,
     foreign_expn_data: UnhashMap<ExpnHash, u32>,
@@ -180,7 +180,7 @@ impl OnDiskCache {
             query_result_index: footer.query_result_index.into_iter().collect(),
             prev_side_effects_index: footer.side_effects_index.into_iter().collect(),
             alloc_decoding_state: AllocDecodingState::new(footer.interpret_alloc_index),
-            syntax_contexts: footer.syntax_contexts,
+            syntax_context_keys: footer.syntax_context_keys,
             expn_data: footer.expn_data,
             foreign_expn_data: footer.foreign_expn_data,
             hygiene_context: Default::default(),
@@ -196,7 +196,7 @@ impl OnDiskCache {
             query_result_index: Default::default(),
             prev_side_effects_index: Default::default(),
             alloc_decoding_state: AllocDecodingState::new(Vec::new()),
-            syntax_contexts: FxHashMap::default(),
+            syntax_context_keys: FxHashMap::default(),
             expn_data: UnhashMap::default(),
             foreign_expn_data: UnhashMap::default(),
             hygiene_context: Default::default(),
@@ -301,7 +301,7 @@ impl OnDiskCache {
                 interpret_alloc_index
             };
 
-            let mut syntax_contexts = FxHashMap::default();
+            let mut syntax_context_keys = FxHashMap::default();
             let mut expn_data = UnhashMap::default();
             let mut foreign_expn_data = UnhashMap::default();
 
@@ -312,8 +312,8 @@ impl OnDiskCache {
                 &mut encoder,
                 |encoder, index, ctxt_data| {
                     let pos = AbsoluteBytePos::new(encoder.position());
-                    encoder.encode_tagged(TAG_SYNTAX_CONTEXT, ctxt_data);
-                    syntax_contexts.insert(index, pos);
+                    encoder.encode_tagged(TAG_SYNTAX_CONTEXT_KEY, &ctxt_data);
+                    syntax_context_keys.insert(index, pos);
                 },
                 |encoder, expn_id, data, hash| {
                     if expn_id.krate == LOCAL_CRATE {
@@ -335,7 +335,7 @@ impl OnDiskCache {
                     query_result_index,
                     side_effects_index,
                     interpret_alloc_index,
-                    syntax_contexts,
+                    syntax_context_keys,
                     expn_data,
                     foreign_expn_data,
                 },
@@ -425,7 +425,7 @@ impl OnDiskCache {
             file_index_to_file: &self.file_index_to_file,
             file_index_to_stable_id: &self.file_index_to_stable_id,
             alloc_decoding_session: self.alloc_decoding_state.new_decoding_session(),
-            syntax_contexts: &self.syntax_contexts,
+            syntax_context_keys: &self.syntax_context_keys,
             expn_data: &self.expn_data,
             foreign_expn_data: &self.foreign_expn_data,
             hygiene_context: &self.hygiene_context,
@@ -445,7 +445,7 @@ pub struct CacheDecoder<'a, 'tcx> {
     file_index_to_file: &'a Lock<FxHashMap<SourceFileIndex, Arc<SourceFile>>>,
     file_index_to_stable_id: &'a FxHashMap<SourceFileIndex, EncodedSourceFileId>,
     alloc_decoding_session: AllocDecodingSession<'a>,
-    syntax_contexts: &'a FxHashMap<u32, AbsoluteBytePos>,
+    syntax_context_keys: &'a FxHashMap<u32, AbsoluteBytePos>,
     expn_data: &'a UnhashMap<ExpnHash, AbsoluteBytePos>,
     foreign_expn_data: &'a UnhashMap<ExpnHash, u32>,
     hygiene_context: &'a HygieneDecodeContext,
@@ -560,13 +560,12 @@ impl<'a, 'tcx> Decodable<CacheDecoder<'a, 'tcx>> for Vec<u8> {
 
 impl<'a, 'tcx> SpanDecoder for CacheDecoder<'a, 'tcx> {
     fn decode_syntax_context(&mut self) -> SyntaxContext {
-        let syntax_contexts = self.syntax_contexts;
         rustc_span::hygiene::decode_syntax_context(self, self.hygiene_context, |this, id| {
             // This closure is invoked if we haven't already decoded the data for the `SyntaxContext` we are deserializing.
             // We look up the position of the associated `SyntaxData` and decode it.
-            let pos = syntax_contexts.get(&id).unwrap();
+            let pos = this.syntax_context_keys.get(&id).unwrap();
             this.with_position(pos.to_usize(), |decoder| {
-                let data: SyntaxContextData = decode_tagged(decoder, TAG_SYNTAX_CONTEXT);
+                let data: SyntaxContextKey = decode_tagged(decoder, TAG_SYNTAX_CONTEXT_KEY);
                 data
             })
         })

compiler/rustc_middle/src/ty/parameterized.rs

@@ -111,6 +111,7 @@ trivially_parameterized_over_tcx! {
     rustc_span::Span,
     rustc_span::Symbol,
     rustc_span::def_id::DefPathHash,
+    rustc_span::hygiene::SyntaxContextKey,
     rustc_span::hygiene::SyntaxContextData,
     rustc_span::Ident,
     rustc_type_ir::Variance,