Use ExternalSyntaxContext for not yet remapped contexts

Author: aerooneqq

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -2042,7 +2042,8 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
             &Rc::clone(&self.hygiene_ctxt),
             &mut (&mut *self, &mut syntax_contexts, &mut expn_data_table, &mut expn_hash_table),
             |(this, syntax_contexts, _, _), ctxt, ctxt_data| {
-                syntax_contexts.set_some(ctxt, this.lazy(ctxt_data));
+                let external_ctxt = ExternalSyntaxContext::from(ctxt);
+                syntax_contexts.set_some(external_ctxt, this.lazy(ctxt_data));
             },
             |(this, _, expn_data_table, expn_hash_table), index, expn_data, hash| {
                 if let Some(index) = index.as_local() {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -46,8 +46,8 @@ use rustc_serialize::opaque::FileEncoder;
 use rustc_session::config::mitigation_coverage::DeniedPartialMitigation;
 use rustc_session::config::{SymbolManglingVersion, TargetModifier};
 use rustc_span::edition::Edition;
-use rustc_span::hygiene::{ExpnIndex, MacroKind, SyntaxContextKey};
-use rustc_span::{self, ExpnData, ExpnHash, ExpnId, Ident, Span, Symbol, SyntaxContext};
+use rustc_span::hygiene::{ExpnIndex, ExternalSyntaxContext, MacroKind, SyntaxContextKey};
+use rustc_span::{self, ExpnData, ExpnHash, ExpnId, Ident, Span, Symbol};
 use rustc_target::spec::{PanicStrategy, TargetTuple};
 use table::TableBuilder;
 
@@ -207,7 +207,7 @@ enum LazyState {
 }
 
 type SyntaxContextTable =
-    LazyTable<SyntaxContext, SyntaxContext, Option<LazyValue<SyntaxContextKey>>>;
+    LazyTable<ExternalSyntaxContext, ExternalSyntaxContext, Option<LazyValue<SyntaxContextKey>>>;
 type ExpnDataTable = LazyTable<ExpnIndex, ExpnIndex, Option<LazyValue<ExpnData>>>;
 type ExpnHashTable = LazyTable<ExpnIndex, ExpnIndex, Option<LazyValue<ExpnHash>>>;
 

compiler/rustc_span/src/hygiene.rs

@@ -1406,7 +1406,7 @@ impl HygieneEncodeContext {
 pub struct HygieneDecodeContext {
     // A cache mapping raw serialized per-crate syntax context ids to corresponding decoded
     // `SyntaxContext`s in the current global `HygieneData`.
-    remapped_ctxts: Lock<IndexVec<SyntaxContext, Option<SyntaxContext>>>,
+    remapped_ctxts: Lock<IndexVec<ExternalSyntaxContext, Option<SyntaxContext>>>,
 }
 
 /// Register an expansion which has been decoded from the on-disk-cache for the local crate.
@@ -1473,16 +1473,37 @@ pub fn decode_expn_id(
     register_expn_id(krate, index, expn_data, hash)
 }
 
+rustc_index::newtype_index! {
+    /// A syntax context that is obtained from metadata of an external crate and
+    /// was not yet remapped to local `SyntaxContext`.
+    #[encodable]
+    pub struct ExternalSyntaxContext {}
+}
+
+impl ExternalSyntaxContext {
+    #[inline(always)]
+    pub fn is_root(self) -> bool {
+        self.as_u32() == 0
+    }
+}
+
+impl From<SyntaxContext> for ExternalSyntaxContext {
+    #[inline]
+    fn from(ctxt: SyntaxContext) -> Self {
+        ExternalSyntaxContext::from_u32(ctxt.as_u32())
+    }
+}
+
 // Decodes `SyntaxContext`, using the provided `HygieneDecodeContext`
 // to track which `SyntaxContext`s we have already decoded.
 // The provided closure will be invoked to deserialize a `SyntaxContextData`
 // if we haven't already seen the id of the `SyntaxContext` we are deserializing.
 pub fn decode_syntax_context<D: Decoder>(
     d: &mut D,
     context: &HygieneDecodeContext,
-    decode_data: impl FnOnce(&mut D, SyntaxContext) -> SyntaxContextKey,
+    decode_data: impl FnOnce(&mut D, ExternalSyntaxContext) -> SyntaxContextKey,
 ) -> SyntaxContext {
-    let external_ctxt = SyntaxContext::from_u32(Decodable::decode(d));
+    let external_ctxt: ExternalSyntaxContext = Decodable::decode(d);
     if external_ctxt.is_root() {
         trace!("decode_syntax_context: deserialized root");
         // The root is special