Also recover type for errors in static items in type_of

The const interner uses the body to intern static allocations.
This means that an allocation will be mutable if the resulting type
contains interior mutability.
Const eval contains an assertion that types that are `Freeze` do not
have mutable allocations, which was failing for cases where the type was
a type error.

An alternative fix for this would be to avoid the assertion in const
eval for type errors, allowing those to both be mutable and immutable.
This is implemented in a follow-up commit as well.

Author: Noratrieb

compiler/rustc_hir/src/hir.rs

@@ -2509,6 +2509,24 @@ impl<'hir> Ty<'hir> {
             _ => false,
         }
     }
+
+    pub fn references_error(&self) -> Option<rustc_span::ErrorGuaranteed> {
+        use crate::intravisit::Visitor;
+        struct ErrVisitor(Option<rustc_span::ErrorGuaranteed>);
+        impl<'v> Visitor<'v> for ErrVisitor {
+            fn visit_ty(&mut self, t: &'v Ty<'v>) {
+                if let TyKind::Err(guar) = t.kind {
+                    self.0 = Some(guar);
+                    return;
+                }
+                crate::intravisit::walk_ty(self, t);
+            }
+        }
+
+        let mut err_visitor = ErrVisitor(None);
+        err_visitor.visit_ty(self);
+        err_visitor.0
+    }
 }
 
 /// Not represented directly in the AST; referred to by name through a `ty_path`.

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -403,7 +403,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<Ty
 
         Node::Item(item) => match item.kind {
             ItemKind::Static(ty, .., body_id) => {
-                if ty.is_suggestable_infer_ty() {
+                if ty.is_suggestable_infer_ty() || ty.references_error().is_some() {
                     infer_placeholder_type(
                         tcx,
                         def_id,