Use sub_unification_table_root_var instead of root_var to check that the ty vars are equal

Author: JonathanBrouwer

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -501,13 +501,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // We demand the type to be equal to the never type, so we can probe the never type for methods
             // (see https://github.com/rust-lang/rust/issues/143349)
             } else if let ty::Infer(ty::TyVar(ty_id)) = *ty.kind()
-                && let ty_id = self.root_var(ty_id)
+                && let ty_id = self.sub_unification_table_root_var(ty_id)
                 && let root_ty = Ty::new_var(self.tcx, ty_id)
                 && self
                     .diverging_type_vars
                     .borrow()
                     .iter()
-                    .any(|&candidate_id| self.root_var(candidate_id) == ty_id)
+                    .any(|&candidate_id| self.sub_unification_table_root_var(candidate_id) == ty_id)
             {
                 self.tcx.emit_node_span_lint(
                     TRAIT_METHOD_ON_COERCED_NEVER_TYPE,

compiler/rustc_infer/src/infer/type_variable.rs

@@ -246,7 +246,7 @@ impl<'tcx> TypeVariableTable<'_, 'tcx> {
     }
 
     /// Returns the "root" variable of `vid` in the `sub_unification_table`
-    /// equivalence table. All type variables that have been are related via
+    /// equivalence table. All type variables that have been related via
     /// equality or subtyping will yield the same root variable (per the
     /// union-find algorithm), so `sub_unification_table_root_var(a)
     /// == sub_unification_table_root_var(b)` implies that:

tests/ui/never_type/basic/method-on-never.rs

@@ -12,6 +12,29 @@ impl Trait for ! {
     }
 }
 
+struct Adhoc;
+struct Error;
+
+#[doc(hidden)]
+trait AdhocKind: Sized {
+    #[inline]
+    fn anyhow_kind(&self) -> Adhoc {
+        Adhoc
+    }
+}
+
+impl<T> AdhocKind for &T where T: ?Sized + Send + Sync + 'static {}
+
+impl Adhoc {
+    #[cold]
+    fn new<M>(self, message: M) -> Error
+    where
+        M: Send + Sync + 'static,
+    {
+        Error
+    }
+}
+
 fn main() {
     let x = loop {};
     x.method();
@@ -21,4 +44,16 @@ fn main() {
     { loop {} }.method();
     //~^ WARN [trait_method_on_coerced_never_type]
     //~| WARN previously accepted
+
+    let e = match loop {} {
+        y => y.method(),
+        //~^ WARN [trait_method_on_coerced_never_type]
+        //~| WARN previously accepted
+    };
+
+    let error = match loop {} {
+        error => (&error).anyhow_kind().new(error),
+        //~^ WARN [trait_method_on_coerced_never_type]
+        //~| WARN previously accepted
+    };
 }

tests/ui/never_type/basic/method-on-never.stderr

@@ -1,5 +1,5 @@
 warning: trait method call on a coerced never type
-  --> $DIR/method-on-never.rs:17:7
+  --> $DIR/method-on-never.rs:40:7
    |
 LL |     x.method();
    |       ^^^^^^
@@ -10,7 +10,7 @@ LL |     x.method();
    = note: `#[warn(trait_method_on_coerced_never_type)]` (part of `#[warn(future_incompatible)]`) on by default
 
 warning: trait method call on a coerced never type
-  --> $DIR/method-on-never.rs:21:17
+  --> $DIR/method-on-never.rs:44:17
    |
 LL |     { loop {} }.method();
    |                 ^^^^^^
@@ -19,11 +19,31 @@ LL |     { loop {} }.method();
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #156047 <https://github.com/rust-lang/rust/issues/156047>
 
-warning: 2 warnings emitted
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:49:16
+   |
+LL |         y => y.method(),
+   |                ^^^^^^
+   |
+   = help: consider providing a type annotation
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #156047 <https://github.com/rust-lang/rust/issues/156047>
+
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:55:27
+   |
+LL |         error => (&error).anyhow_kind().new(error),
+   |                           ^^^^^^^^^^^
+   |
+   = help: consider providing a type annotation
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #156047 <https://github.com/rust-lang/rust/issues/156047>
+
+warning: 4 warnings emitted
 
 Future incompatibility report: Future breakage diagnostic:
 warning: trait method call on a coerced never type
-  --> $DIR/method-on-never.rs:17:7
+  --> $DIR/method-on-never.rs:40:7
    |
 LL |     x.method();
    |       ^^^^^^
@@ -35,7 +55,7 @@ LL |     x.method();
 
 Future breakage diagnostic:
 warning: trait method call on a coerced never type
-  --> $DIR/method-on-never.rs:21:17
+  --> $DIR/method-on-never.rs:44:17
    |
 LL |     { loop {} }.method();
    |                 ^^^^^^
@@ -45,3 +65,27 @@ LL |     { loop {} }.method();
    = note: for more information, see issue #156047 <https://github.com/rust-lang/rust/issues/156047>
    = note: `#[warn(trait_method_on_coerced_never_type)]` (part of `#[warn(future_incompatible)]`) on by default
 
+Future breakage diagnostic:
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:49:16
+   |
+LL |         y => y.method(),
+   |                ^^^^^^
+   |
+   = help: consider providing a type annotation
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` (part of `#[warn(future_incompatible)]`) on by default
+
+Future breakage diagnostic:
+warning: trait method call on a coerced never type
+  --> $DIR/method-on-never.rs:55:27
+   |
+LL |         error => (&error).anyhow_kind().new(error),
+   |                           ^^^^^^^^^^^
+   |
+   = help: consider providing a type annotation
+   = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
+   = note: for more information, see issue #156047 <https://github.com/rust-lang/rust/issues/156047>
+   = note: `#[warn(trait_method_on_coerced_never_type)]` (part of `#[warn(future_incompatible)]`) on by default
+