remove an unnecessary negation

I think in this case the early return is harder to read than just an if.
"if fallback hasn't occured we don't do..."

compiler/rustc_hir_typeck/src/fallback.rs

diff --git a/compiler/rustc_hir_typeck/src/fallback.rs b/compiler/rustc_hir_typeck/src/fallback.rs
index 0d90519..27a15b3 100644
--- a/compiler/rustc_hir_typeck/src/fallback.rs
+++ b/compiler/rustc_hir_typeck/src/fallback.rs
@@ -49,34 +49,32 @@ pub(super) fn type_inference_fallback(&self) {
 
         let fallback_occurred = self.fallback_types();
 
-        if !fallback_occurred {
-            return;
+        if fallback_occurred {
+            // We now see if we can make progress. This might cause us to
+            // unify inference variables for opaque types, since we may
+            // have unified some other type variables during the first
+            // phase of fallback. This means that we only replace
+            // inference variables with their underlying opaque types as a
+            // last resort.
+            //
+            // In code like this:
+            //
+            // ```rust
+            // type MyType = impl Copy;
+            // fn produce() -> MyType { true }
+            // fn bad_produce() -> MyType { panic!() }
+            // ```
+            //
+            // we want to unify the opaque inference variable in `bad_produce`
+            // with the diverging fallback for `panic!` (e.g. `()` or `!`).
+            // This will produce a nice error message about conflicting concrete
+            // types for `MyType`.
+            //
+            // If we had tried to fallback the opaque inference variable to `MyType`,
+            // we will generate a confusing type-check error that does not explicitly
+            // refer to opaque types.
+            self.select_obligations_where_possible(|_| {});
         }
-
-        // We now see if we can make progress. This might cause us to
-        // unify inference variables for opaque types, since we may
-        // have unified some other type variables during the first
-        // phase of fallback. This means that we only replace
-        // inference variables with their underlying opaque types as a
-        // last resort.
-        //
-        // In code like this:
-        //
-        // ```rust
-        // type MyType = impl Copy;
-        // fn produce() -> MyType { true }
-        // fn bad_produce() -> MyType { panic!() }
-        // ```
-        //
-        // we want to unify the opaque inference variable in `bad_produce`
-        // with the diverging fallback for `panic!` (e.g. `()` or `!`).
-        // This will produce a nice error message about conflicting concrete
-        // types for `MyType`.
-        //
-        // If we had tried to fallback the opaque inference variable to `MyType`,
-        // we will generate a confusing type-check error that does not explicitly
-        // refer to opaque types.
-        self.select_obligations_where_possible(|_| {});
     }
 
     fn fallback_types(&self) -> bool {