Fix trait method resolution on an adjusted never type

Author: JonathanBrouwer

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -459,6 +459,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // If we encountered an `_` type or an error type during autoderef, this is
         // ambiguous.
         if let Some(bad_ty) = &steps.opt_bad_ty {
+            // Ended up encountering a type variable when doing autoderef,
+            // but it may not be a type variable after processing obligations
+            // in our local `FnCtxt`, so don't call `structurally_resolve_type`.
+            let ty = &bad_ty.ty;
+            let ty = self
+                .probe_instantiate_query_response(span, &orig_values, ty)
+                .unwrap_or_else(|_| span_bug!(span, "instantiating {:?} failed?", ty));
+            let ty = self.resolve_vars_if_possible(ty.value);
+
             if is_suggestion.0 {
                 // Ambiguity was encountered during a suggestion. There's really
                 // not much use in suggesting methods in this case.
@@ -482,15 +491,20 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     span,
                     MissingTypeAnnot,
                 );
+            // If `ty` is an inference variable that was created by being adjusted from the never type,
+            // 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 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)
+            {
+                self.demand_eqtype(span, root_ty, self.tcx.types.never);
             } else {
-                // Ended up encountering a type variable when doing autoderef,
-                // but it may not be a type variable after processing obligations
-                // in our local `FnCtxt`, so don't call `structurally_resolve_type`.
-                let ty = &bad_ty.ty;
-                let ty = self
-                    .probe_instantiate_query_response(span, &orig_values, ty)
-                    .unwrap_or_else(|_| span_bug!(span, "instantiating {:?} failed?", ty));
-                let ty = self.resolve_vars_if_possible(ty.value);
                 let guar = match *ty.kind() {
                     _ if let Some(guar) = self.tainted_by_errors() => guar,
                     ty::Infer(ty::TyVar(_)) => {

tests/ui/never_type/basic/clone-never.rs

@@ -1,6 +1,7 @@
-//! regression test for issue #2151
+//@ check-pass
+// Regression test for https://github.com/rust-lang/rust/issues/143349
 
 fn main() {
-    let x = panic!(); //~ ERROR type annotations needed
+    let x = panic!();
     x.clone();
 }

tests/ui/never_type/basic/clone-never.stderr

@@ -1,16 +0,0 @@
-error[E0282]: type annotations needed
-  --> $DIR/clone-never.rs:4:9
-   |
-LL |     let x = panic!();
-   |         ^
-LL |     x.clone();
-   |     - type must be known at this point
-   |
-help: consider giving `x` an explicit type
-   |
-LL |     let x: /* Type */ = panic!();
-   |          ++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0282`.

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

@@ -0,0 +1,20 @@
+//@ check-pass
+// Regression test for https://github.com/rust-lang/rust/issues/143349
+
+#![feature(never_type)]
+
+trait Trait {
+    fn method(&self);
+}
+impl Trait for ! {
+    fn method(&self) {
+        todo!()
+    }
+}
+
+fn main() {
+    let x = loop {};
+    x.method();
+
+    { loop {} }.method();
+}