Don't cache stable hashes in types outside of incremental mode

Author: oli-obk

Diff for: compiler/rustc_middle/src/ty/context.rs

@@ -153,7 +153,11 @@ impl<'tcx> CtxtInterners<'tcx> {
                 .intern(kind, |kind| {
                     let flags = super::flags::FlagComputation::for_kind(&kind);
 
-                    let stable_hash = if flags.flags.intersects(TypeFlags::HAS_RE_INFER) {
+                    // It's impossible to hash inference regions (and will ICE), so we don't need to try to cache them.
+                    // Without incremental, we rarely stable-hash types, so let's not do it proactively.
+                    let stable_hash = if flags.flags.intersects(TypeFlags::HAS_RE_INFER)
+                        || sess.opts.incremental.is_none()
+                    {
                         Fingerprint::ZERO
                     } else {
                         let mut hasher = StableHasher::new();

Diff for: compiler/rustc_middle/src/ty/mod.rs

@@ -464,8 +464,20 @@ impl<'a, 'tcx> HashStable<StableHashingContext<'a>> for Ty<'tcx> {
             stable_hash,
         } = self.0.0;
 
-        assert_ne!(*stable_hash, Fingerprint::ZERO, "{:#?}", kind);
-        stable_hash.hash_stable(hcx, hasher);
+        if *stable_hash == Fingerprint::ZERO {
+            // No cached hash available. This can only mean that incremental is disabled.
+            // We don't cache stable hashes in non-incremental mode, because they are used
+            // so rarely that the performance actually suffers.
+
+            let stable_hash: Fingerprint = {
+                let mut hasher = StableHasher::new();
+                kind.hash_stable(hcx, &mut hasher);
+                hasher.finish()
+            };
+            stable_hash.hash_stable(hcx, hasher);
+        } else {
+            stable_hash.hash_stable(hcx, hasher);
+        }
     }
 }