diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 786754ed12f09..bd2454f6368d3 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -279,13 +279,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
             Entry::Occupied(mut entry) => {
                 debug!(" - composing on top of {:?}", entry.get());
-                match (&entry.get()[..], &adj[..]) {
-                    // Applying any adjustment on top of a NeverToAny
-                    // is a valid NeverToAny adjustment, because it can't
-                    // be reached.
-                    (&[Adjustment { kind: Adjust::NeverToAny, .. }], _) => return,
+                match (&mut entry.get_mut()[..], &adj[..]) {
                     (
-                        &[
+                        [Adjustment { kind: Adjust::NeverToAny, target }],
+                        &[.., Adjustment { target: new_target, .. }],
+                    ) => {
+                        // NeverToAny coercion can target any type, so instead of adding a new
+                        // adjustment on top we can change the target.
+                        //
+                        // This is required for things like `a == a` (where `a: !`) to produce
+                        // valid MIR -- we need borrow adjustment from things like `==` to change
+                        // the type to `&!` (or `&()` depending on the fallback). This might be
+                        // relevant even in unreachable code.
+                        *target = new_target;
+                    }
+
+                    (
+                        &mut [
                             Adjustment { kind: Adjust::Deref(_), .. },
                             Adjustment { kind: Adjust::Borrow(AutoBorrow::Ref(..)), .. },
                         ],
@@ -294,11 +304,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             .., // Any following adjustments are allowed.
                         ],
                     ) => {
-                        // A reborrow has no effect before a dereference.
+                        // A reborrow has no effect before a dereference, so we can safely replace adjustments.
+                        *entry.get_mut() = adj;
                     }
-                    // FIXME: currently we never try to compose autoderefs
-                    // and ReifyFnPointer/UnsafeFnPointer, but we could.
+
                     _ => {
+                        // FIXME: currently we never try to compose autoderefs
+                        // and ReifyFnPointer/UnsafeFnPointer, but we could.
                         self.dcx().span_delayed_bug(
                             expr.span,
                             format!(
@@ -308,9 +320,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                                 adj
                             ),
                         );
+
+                        *entry.get_mut() = adj;
                     }
                 }
-                *entry.get_mut() = adj;
             }
         }
 
diff --git a/tests/crashes/120600-2.rs b/tests/crashes/120600-2.rs
deleted file mode 100644
index aa1785eea84c4..0000000000000
--- a/tests/crashes/120600-2.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #120600
-#![feature(never_type, never_type_fallback)]
-
-enum E { Bar(!) }
-
-fn f(a: &E, b: &E) {
-    match (a, b) {
-        (E::Bar(a), E::Bar(b)) => { *a == *b; }
-        _ => {}
-    }
-}
-
-pub fn main() {}
diff --git a/tests/crashes/120600.rs b/tests/crashes/120600.rs
deleted file mode 100644
index 1be51a8da1602..0000000000000
--- a/tests/crashes/120600.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-//@ known-bug: #120600
-#![feature(never_type)]
-#![feature(never_type_fallback)]
-
-#[derive(Ord, Eq, PartialOrd, PartialEq)]
-enum E {
-    Foo,
-    Bar(!, i32, i32),
-}
-
-fn main() {}
diff --git a/tests/mir-opt/building/eq_never_type._f.built.after.mir b/tests/mir-opt/building/eq_never_type._f.built.after.mir
new file mode 100644
index 0000000000000..39438258c2ebb
--- /dev/null
+++ b/tests/mir-opt/building/eq_never_type._f.built.after.mir
@@ -0,0 +1,53 @@
+// MIR for `_f` after built
+
+fn _f(_1: !, _2: !) -> () {
+    debug a => _1;
+    debug b => _2;
+    let mut _0: ();
+    let mut _3: !;
+    let _4: bool;
+    let mut _5: &();
+    let mut _6: !;
+    let mut _7: &();
+    let _8: ();
+    let mut _9: !;
+
+    bb0: {
+        StorageLive(_4);
+        StorageLive(_5);
+        StorageLive(_6);
+        _6 = _1;
+        unreachable;
+    }
+
+    bb1: {
+        StorageDead(_6);
+        StorageLive(_7);
+        StorageLive(_8);
+        StorageLive(_9);
+        _9 = _2;
+        unreachable;
+    }
+
+    bb2: {
+        _7 = &_8;
+        StorageDead(_9);
+        _4 = <() as PartialEq>::eq(move _5, move _7) -> [return: bb3, unwind: bb5];
+    }
+
+    bb3: {
+        StorageDead(_7);
+        StorageDead(_5);
+        StorageDead(_8);
+        StorageDead(_4);
+        unreachable;
+    }
+
+    bb4: {
+        return;
+    }
+
+    bb5 (cleanup): {
+        resume;
+    }
+}
diff --git a/tests/mir-opt/building/eq_never_type.rs b/tests/mir-opt/building/eq_never_type.rs
new file mode 100644
index 0000000000000..90e2e69753531
--- /dev/null
+++ b/tests/mir-opt/building/eq_never_type.rs
@@ -0,0 +1,13 @@
+// skip-filecheck
+#![feature(never_type)]
+#![allow(unreachable_code)]
+
+// EMIT_MIR eq_never_type._f.built.after.mir
+fn _f(a: !, b: !) {
+    // Both arguments must be references (i.e. == should auto-borrow/coerce-to-ref both arguments)
+    // (this previously was buggy due to `NeverToAny` coercion incorrectly throwing out other
+    // coercions)
+    a == b;
+}
+
+fn main() {}
diff --git a/tests/ui/never_type/eq-never-types.rs b/tests/ui/never_type/eq-never-types.rs
new file mode 100644
index 0000000000000..19717fcf4433c
--- /dev/null
+++ b/tests/ui/never_type/eq-never-types.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+//
+// issue: rust-lang/rust#120600
+
+#![allow(internal_features)]
+#![feature(never_type, rustc_attrs)]
+#![rustc_never_type_options(fallback = "never")]
+
+fn ice(a: !) {
+    a == a;
+}
+
+fn main() {}