Adjust assert_default_hashing_controls

compiler/rustc_query_system/src/ich/hcx.rs

@@ -27,6 +27,7 @@ fn compute_ignored_attr_names() -> FxHashSet<Symbol> {
 pub struct StableHashingContext<'a> {
     definitions: &'a Definitions,
     cstore: &'a dyn CrateStore,
+    sess: &'a Session,
     pub(super) body_resolver: BodyResolver<'a>,
     // Very often, we are hashing something that does not need the
     // `CachingSourceMapView`, so we initialize it lazily.
@@ -63,6 +64,7 @@ impl<'a> StableHashingContext<'a> {
             body_resolver: BodyResolver::Forbidden,
             definitions,
             cstore,
+            sess,
             caching_source_map: None,
             raw_source_map: sess.source_map(),
             hashing_controls: HashingControls {
@@ -197,6 +199,11 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
         self.hashing_controls.hash_spans
     }
 
+    #[inline]
+    fn debug_opts_incremental_ignore_spans(&self) -> bool {
+        self.sess.opts.debugging_opts.incremental_ignore_spans
+    }
+
     #[inline]
     fn def_path_hash(&self, def_id: DefId) -> DefPathHash {
         self.def_path_hash(def_id)

compiler/rustc_span/src/hygiene.rs

@@ -89,11 +89,11 @@ rustc_index::newtype_index! {
     }
 }
 
-// Assert that the provided `HashStableContext` is configured with the 'default'
+/// Assert that the provided `HashStableContext` is configured with the 'default'
-// `HashingControls`. We should always have bailed out before getting to here
+/// `HashingControls`. We should always have bailed out before getting to here
-// with a non-default mode. With this check in place, we can avoid the need
+/// with a non-default mode. With this check in place, we can avoid the need
-// to maintain separate versions of `ExpnData` hashes for each permutation
+/// to maintain separate versions of `ExpnData` hashes for each permutation
-// of `HashingControls` settings.
+/// of `HashingControls` settings.
 fn assert_default_hashing_controls<CTX: HashStableContext>(ctx: &CTX, msg: &str) {
     match ctx.hashing_controls() {
         // Ideally, we would also check that `node_id_hashing_mode` was always
@@ -105,7 +105,13 @@ fn assert_default_hashing_controls<CTX: HashStableContext>(ctx: &CTX, msg: &str)
         // FIXME: Enforce that we don't end up transitively hashing any `HirId`s,
         // or ensure that this method is always invoked with the same
         // `NodeIdHashingMode`
-        HashingControls { hash_spans: true, node_id_hashing_mode: _ } => {}
+        //
+        // Note that we require that `hash_spans` be set according to the global
+        // `-Z incremental-ignore-spans` option. Normally, this option is disabled,
+        // which will cause us to require that this method always be called with `Span` hashing
+        // enabled.
+        HashingControls { hash_spans, node_id_hashing_mode: _ }
+            if hash_spans == !ctx.debug_opts_incremental_ignore_spans() => {}
         other => panic!("Attempted hashing of {msg} with non-default HashingControls: {:?}", other),
     }
 }

compiler/rustc_span/src/lib.rs

@@ -2058,6 +2058,9 @@ impl InnerSpan {
 pub trait HashStableContext {
     fn def_path_hash(&self, def_id: DefId) -> DefPathHash;
     fn hash_spans(&self) -> bool;
+    /// Accesses `sess.opts.debugging_opts.incremental_ignore_spans` since
+    /// we don't have easy access to a `Session`
+    fn debug_opts_incremental_ignore_spans(&self) -> bool;
     fn def_span(&self, def_id: LocalDefId) -> Span;
     fn span_data_to_lines_and_cols(
         &mut self,