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,15 @@ 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 root_ty = Ty::new_var(self.tcx, self.root_var(ty_id))
+                && self.diverging_type_vars.borrow().contains(&root_ty)
+            {
+                self.demand_eqtype(DUMMY_SP, 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

@@ -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();
+}