make all typing-mode conditional code an exhaustive match

Author: jdonszelmann

compiler/rustc_next_trait_solver/src/canonical/mod.rs

@@ -16,8 +16,8 @@ use rustc_index::IndexVec;
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::solver_relating::RelateExt;
 use rustc_type_ir::{
-    self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, TypingModeEqWrapper, InferCtxtLike,
-    Interner, TypeFoldable,
+    self as ty, Canonical, CanonicalVarKind, CanonicalVarValues, InferCtxtLike, Interner,
+    TypeFoldable, TypingModeEqWrapper,
 };
 use tracing::instrument;
 
@@ -66,8 +66,10 @@ where
             predefined_opaques_in_body: delegate.cx().mk_predefined_opaques_in_body(opaque_types),
         },
     );
-    let query_input =
-        ty::CanonicalQueryInput { canonical, typing_mode: TypingModeEqWrapper(delegate.typing_mode()) };
+    let query_input = ty::CanonicalQueryInput {
+        canonical,
+        typing_mode: TypingModeEqWrapper(delegate.typing_mode()),
+    };
     (orig_values, query_input)
 }
 

compiler/rustc_type_ir/src/canonical.rs

@@ -11,7 +11,7 @@ use rustc_type_ir_macros::{
 
 use crate::data_structures::HashMap;
 use crate::inherent::*;
-use crate::{self as ty, TypingModeEqWrapper, Interner, UniverseIndex};
+use crate::{self as ty, Interner, TypingModeEqWrapper, UniverseIndex};
 
 #[derive_where(Clone, Hash, PartialEq, Debug; I: Interner, V)]
 #[derive_where(Copy; I: Interner, V: Copy)]

tests/ui-fulldeps/internal-lints/must_match_exhaustively.rs

@@ -5,44 +5,43 @@
 #![feature(rustc_attrs)]
 #![deny(rustc::rustc_must_match_exhaustively)]
 
-
 #[rustc_must_match_exhaustively]
 #[derive(Copy, Clone)]
 enum Foo {
-    A {field: u32},
+    A { field: u32 },
     B,
 }
 
 fn foo(f: Foo) {
     match f {
-        Foo::A {..}=> {}
+        Foo::A { .. } => {}
         Foo::B => {}
     }
 
     match f {
         //~^ ERROR match is not exhaustive
-        Foo::A {..} => {}
+        Foo::A { .. } => {}
         _ => {}
     }
 
     match f {
         //~^ ERROR match is not exhaustive
-        Foo::A {..} => {}
+        Foo::A { .. } => {}
         a => {}
     }
 
     match &f {
         //~^ ERROR match is not exhaustive
-        Foo::A {..} => {}
+        Foo::A { .. } => {}
         a => {}
     }
 
     match f {
-        Foo::A {..} => {}
-        a@Foo::B => {}
+        Foo::A { .. } => {}
+        a @ Foo::B => {}
     }
 
-    if let Foo::A {..} = f {}
+    if let Foo::A { .. } = f {}
     //~^ ERROR match is not exhaustive
 }