Propagate pattern errors via a new PatKind::Error variant

Nadrieril · Nadrieril · commit aab3b9327ed2 · 2023-10-14T13:38:02.000+02:00
Instead of via `Const::new_error`
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
@@ -19,11 +19,12 @@ use rustc_middle::middle::region;
 use rustc_middle::mir::interpret::AllocId;
 use rustc_middle::mir::{self, BinOp, BorrowKind, FakeReadCause, Mutability, UnOp};
 use rustc_middle::ty::adjustment::PointerCoercion;
-use rustc_middle::ty::GenericArgsRef;
-use rustc_middle::ty::{self, AdtDef, FnSig, List, Ty, UpvarArgs};
-use rustc_middle::ty::{CanonicalUserType, CanonicalUserTypeAnnotation};
+use rustc_middle::ty::{
+    self, AdtDef, CanonicalUserType, CanonicalUserTypeAnnotation, FnSig, GenericArgsRef, List, Ty,
+    UpvarArgs,
+};
 use rustc_span::def_id::LocalDefId;
-use rustc_span::{sym, Span, Symbol, DUMMY_SP};
+use rustc_span::{sym, ErrorGuaranteed, Span, Symbol, DUMMY_SP};
 use rustc_target::abi::{FieldIdx, VariantIdx};
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use std::fmt;
@@ -632,7 +633,7 @@ impl<'tcx> Pat<'tcx> {
 
         use PatKind::*;
         match &self.kind {
-            Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } => {}
+            Wild | Range(..) | Binding { subpattern: None, .. } | Constant { .. } | Error(_) => {}
             AscribeUserType { subpattern, .. }
             | Binding { subpattern: Some(subpattern), .. }
             | Deref { subpattern } => subpattern.walk_(it),
@@ -647,6 +648,21 @@ impl<'tcx> Pat<'tcx> {
         }
     }
 
+    /// Whether the pattern has a `PatKind::Error` nested within.
+    pub fn pat_error_reported(&self) -> Result<(), ErrorGuaranteed> {
+        let mut error = None;
+        self.walk(|pat| {
+            if let PatKind::Error(e) = pat.kind && error.is_none() {
+                error = Some(e);
+            }
+            error.is_none()
+        });
+        match error {
+            None => Ok(()),
+            Some(e) => Err(e),
+        }
+    }
+
     /// Walk the pattern in left-to-right order.
     ///
     /// If you always want to recurse, prefer this method over `walk`.
@@ -771,6 +787,10 @@ pub enum PatKind<'tcx> {
     Or {
         pats: Box<[Box<Pat<'tcx>>]>,
     },
+
+    /// An error has been encountered during lowering. We probably shouldn't report more lints
+    /// related to this pattern.
+    Error(ErrorGuaranteed),
 }
 
 #[derive(Clone, Debug, PartialEq, HashStable, TypeVisitable)]
@@ -934,6 +954,7 @@ impl<'tcx> fmt::Display for Pat<'tcx> {
                 }
                 Ok(())
             }
+            PatKind::Error(_) => write!(f, "<error>"),
         }
     }
 }
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
@@ -226,7 +226,7 @@ pub fn walk_pat<'a, 'tcx: 'a, V: Visitor<'a, 'tcx>>(visitor: &mut V, pat: &Pat<'
             is_primary: _,
             name: _,
         } => visitor.visit_pat(&subpattern),
-        Binding { .. } | Wild => {}
+        Binding { .. } | Wild | Error(_) => {}
         Variant { subpatterns, adt_def: _, args: _, variant_index: _ } | Leaf { subpatterns } => {
             for subpattern in subpatterns {
                 visitor.visit_pat(&subpattern.pattern);
diff --git a/compiler/rustc_mir_build/src/build/matches/mod.rs b/compiler/rustc_mir_build/src/build/matches/mod.rs
@@ -814,7 +814,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 }
             }
 
-            PatKind::Constant { .. } | PatKind::Range { .. } | PatKind::Wild => {}
+            PatKind::Constant { .. }
+            | PatKind::Range { .. }
+            | PatKind::Wild
+            | PatKind::Error(_) => {}
 
             PatKind::Deref { ref subpattern } => {
                 self.visit_primary_bindings(subpattern, pattern_user_ty.deref(), f);
diff --git a/compiler/rustc_mir_build/src/build/matches/simplify.rs b/compiler/rustc_mir_build/src/build/matches/simplify.rs
@@ -168,7 +168,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 Ok(())
             }
 
-            PatKind::Wild => {
+            PatKind::Wild | PatKind::Error(_) => {
                 // nothing left to do
                 Ok(())
             }
diff --git a/compiler/rustc_mir_build/src/build/matches/test.rs b/compiler/rustc_mir_build/src/build/matches/test.rs
@@ -77,7 +77,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | PatKind::Wild
             | PatKind::Binding { .. }
             | PatKind::Leaf { .. }
-            | PatKind::Deref { .. } => self.error_simplifiable(match_pair),
+            | PatKind::Deref { .. }
+            | PatKind::Error(_) => self.error_simplifiable(match_pair),
         }
     }
 
@@ -111,7 +112,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             | PatKind::Binding { .. }
             | PatKind::AscribeUserType { .. }
             | PatKind::Leaf { .. }
-            | PatKind::Deref { .. } => {
+            | PatKind::Deref { .. }
+            | PatKind::Error(_) => {
                 // don't know how to add these patterns to a switch
                 false
             }
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -224,7 +224,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 PatKind::Wild |
                 // these just wrap other patterns
                 PatKind::Or { .. } |
-                PatKind::AscribeUserType { .. } => {}
+                PatKind::AscribeUserType { .. } |
+                PatKind::Error(_) => {}
             }
         };
 
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -19,7 +19,7 @@ use rustc_hir::HirId;
 use rustc_middle::thir::visit::{self, Visitor};
 use rustc_middle::thir::*;
 use rustc_middle::ty::print::with_no_trimmed_paths;
-use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, AdtDef, Ty, TyCtxt};
 use rustc_session::lint::builtin::{
     BINDINGS_WITH_VARIANT_NAME, IRREFUTABLE_LET_PATTERNS, UNREACHABLE_PATTERNS,
 };
@@ -683,7 +683,7 @@ fn non_exhaustive_match<'p, 'tcx>(
     expr_span: Span,
 ) -> ErrorGuaranteed {
     for &arm in arms {
-        if let Err(err) = thir[arm].pattern.error_reported() {
+        if let Err(err) = thir[arm].pattern.pat_error_reported() {
             return err;
         }
     }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/const_to_pat.rs
@@ -196,9 +196,7 @@ impl<'tcx> ConstToPat<'tcx> {
                     };
                     // All branches above emitted an error. Don't print any more lints.
                     // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                    let kind = PatKind::Constant {
-                        value: mir::Const::Ty(ty::Const::new_error(self.tcx(), e, cv.ty())),
-                    };
+                    let kind = PatKind::Error(e);
                     return Box::new(Pat { span: self.span, ty: cv.ty(), kind });
                 } else if !self.saw_const_match_lint.get() {
                     if let Some(mir_structural_match_violation) = mir_structural_match_violation {
@@ -351,15 +349,15 @@ impl<'tcx> ConstToPat<'tcx> {
                 let e = tcx.sess.emit_err(InvalidPattern { span, non_sm_ty: ty });
                 self.saw_const_match_error.set(Some(e));
                 // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
+                PatKind::Error(e)
             }
             ty::Adt(adt_def, _) if !self.type_marked_structural(ty) => {
                 debug!("adt_def {:?} has !type_marked_structural for cv.ty: {:?}", adt_def, ty,);
                 let err = TypeNotStructural { span, non_sm_ty: ty };
                 let e = tcx.sess.emit_err(err);
                 self.saw_const_match_error.set(Some(e));
                 // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
+                PatKind::Error(e)
             }
             ty::Adt(adt_def, args) if adt_def.is_enum() => {
                 let (&variant_index, fields) = cv.unwrap_branch().split_first().unwrap();
@@ -434,17 +432,13 @@ impl<'tcx> ConstToPat<'tcx> {
                     } else {
                         if let Some(e) = self.saw_const_match_error.get() {
                             // We already errored. Signal that in the pattern, so that follow up errors can be silenced.
-                            PatKind::Constant {
-                                value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
-                            }
+                            PatKind::Error(e)
                         } else {
                             let err = TypeNotStructural { span, non_sm_ty: *pointee_ty };
                             let e = tcx.sess.emit_err(err);
                             self.saw_const_match_error.set(Some(e));
                             // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                            PatKind::Constant {
-                                value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
-                            }
+                            PatKind::Error(e)
                         }
                     }
                 }
@@ -456,9 +450,7 @@ impl<'tcx> ConstToPat<'tcx> {
                         let err = UnsizedPattern { span, non_sm_ty: *pointee_ty };
                         let e = tcx.sess.emit_err(err);
                         // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                        PatKind::Constant {
-                            value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)),
-                        }
+                        PatKind::Error(e)
                     } else {
                         let old = self.behind_reference.replace(true);
                         // `b"foo"` produces a `&[u8; 3]`, but you can't use constants of array type when
@@ -489,7 +481,7 @@ impl<'tcx> ConstToPat<'tcx> {
                 let e = tcx.sess.emit_err(err);
                 self.saw_const_match_error.set(Some(e));
                 // We errored. Signal that in the pattern, so that follow up errors can be silenced.
-                PatKind::Constant { value: mir::Const::Ty(ty::Const::new_error(tcx, e, ty)) }
+                PatKind::Error(e)
             }
         };
 
diff --git a/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs b/compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs
@@ -1525,6 +1525,10 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
                 let pats = expand_or_pat(pat);
                 fields = Fields::from_iter(cx, pats.into_iter().map(mkpat));
             }
+            PatKind::Error(_) => {
+                ctor = Opaque;
+                fields = Fields::empty();
+            }
         }
         DeconstructedPat::new(ctor, fields, pat.ty, pat.span)
     }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -791,6 +791,7 @@ impl<'tcx> PatternFoldable<'tcx> for PatKind<'tcx> {
     fn super_fold_with<F: PatternFolder<'tcx>>(&self, folder: &mut F) -> Self {
         match *self {
             PatKind::Wild => PatKind::Wild,
+            PatKind::Error(e) => PatKind::Error(e),
             PatKind::AscribeUserType {
                 ref subpattern,
                 ascription: Ascription { ref annotation, variance },
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
@@ -757,6 +757,9 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 print_indented!(self, "]", depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);
             }
+            PatKind::Error(_) => {
+                print_indented!(self, "Error", depth_lvl + 1);
+            }
         }
 
         print_indented!(self, "}", depth_lvl);
diff --git a/tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr b/tests/ui/const-generics/generic_const_exprs/typeid-equality-by-subtyping.stderr
@@ -7,17 +7,5 @@ LL |         WHAT_A_TYPE => 0,
    = note: the traits must be derived, manual `impl`s are not sufficient
    = note: see https://doc.rust-lang.org/stable/std/marker/trait.StructuralEq.html for details
 
-error[E0015]: cannot match on `TypeId` in constant functions
-  --> $DIR/typeid-equality-by-subtyping.rs:18:9
-   |
-LL |         WHAT_A_TYPE => 0,
-   |         ^^^^^^^^^^^
-   |
-   = note: `TypeId` cannot be compared in compile-time, and therefore cannot be used in `match`es
-note: impl defined here, but it is not `const`
-  --> $SRC_DIR/core/src/any.rs:LL:COL
-   = note: calls in constant functions are limited to constant functions, tuple structs and tuple variants
-
-error: aborting due to 2 previous errors
+error: aborting due to previous error
 
-For more information about this error, try `rustc --explain E0015`.

Original file line number	Diff line number	Diff line change
`@@ -814,7 +814,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`814`	`814`	`}`
`815`	`815`	`}`
`816`	`816`
`817`		`- PatKind::Constant { .. } \| PatKind::Range { .. } \| PatKind::Wild => {}`
	`817`	`+ PatKind::Constant { .. }`
	`818`	`+ \| PatKind::Range { .. }`
	`819`	`+ \| PatKind::Wild`
	`820`	`+ \| PatKind::Error(_) => {}`
`818`	`821`
`819`	`822`	`PatKind::Deref { ref subpattern } => {`
`820`	`823`	`self.visit_primary_bindings(subpattern, pattern_user_ty.deref(), f);`
Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`168`	`168`	`Ok(())`
`169`	`169`	`}`
`170`	`170`
`171`		`- PatKind::Wild => {`
	`171`	`+ PatKind::Wild \| PatKind::Error(_) => {`
`172`	`172`	`// nothing left to do`
`173`	`173`	`Ok(())`
`174`	`174`	`}`
Original file line number	Diff line number	Diff line change
`@@ -77,7 +77,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`77`	`77`	`\| PatKind::Wild`
`78`	`78`	`\| PatKind::Binding { .. }`
`79`	`79`	`\| PatKind::Leaf { .. }`
`80`		`- \| PatKind::Deref { .. } => self.error_simplifiable(match_pair),`
	`80`	`+ \| PatKind::Deref { .. }`
	`81`	`+ \| PatKind::Error(_) => self.error_simplifiable(match_pair),`
`81`	`82`	`}`
`82`	`83`	`}`
`83`	`84`
`@@ -111,7 +112,8 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {`
`111`	`112`	`\| PatKind::Binding { .. }`
`112`	`113`	`\| PatKind::AscribeUserType { .. }`
`113`	`114`	`\| PatKind::Leaf { .. }`
`114`		`- \| PatKind::Deref { .. } => {`
	`115`	`+ \| PatKind::Deref { .. }`
	`116`	`+ \| PatKind::Error(_) => {`
`115`	`117`	`// don't know how to add these patterns to a switch`
`116`	`118`	`false`
`117`	`119`	`}`
Original file line number	Diff line number	Diff line change
`@@ -224,7 +224,8 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {`
`224`	`224`	`PatKind::Wild \|`
`225`	`225`	`// these just wrap other patterns`
`226`	`226`	`PatKind::Or { .. } \|`
`227`		`- PatKind::AscribeUserType { .. } => {}`
	`227`	`+ PatKind::AscribeUserType { .. } \|`
	`228`	`+ PatKind::Error(_) => {}`
`228`	`229`	`}`
`229`	`230`	`};`
`230`	`231`
Original file line number	Diff line number	Diff line change
`@@ -1525,6 +1525,10 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {`
`1525`	`1525`	`let pats = expand_or_pat(pat);`
`1526`	`1526`	`fields = Fields::from_iter(cx, pats.into_iter().map(mkpat));`
`1527`	`1527`	`}`
	`1528`	`+ PatKind::Error(_) => {`
	`1529`	`+ ctor = Opaque;`
	`1530`	`+ fields = Fields::empty();`
	`1531`	`+ }`
`1528`	`1532`	`}`
`1529`	`1533`	`DeconstructedPat::new(ctor, fields, pat.ty, pat.span)`
`1530`	`1534`	`}`