Tidy

Author: tiif

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -162,21 +162,21 @@ where
             }
         }
 
-       // During codegen we must assume that all feature bounds hold as we may be
-       // monomorphizing a body from an upstream crate which had an unstable feature
-       // enabled that we do not.
-       //
-       // Note: `feature_bound_holds_in_crate` does not consider a feature to be enabled
-       // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
-       if self.cx().features().feature_bound_holds_in_crate(symbol)
-           || (self.typing_mode() == TypingMode::PostAnalysis) {
-           return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
-       } else {
-           return self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe(
-               MaybeCause::Ambiguity,
-           ));
-       }
-
+        // During codegen we must assume that all feature bounds hold as we may be
+        // monomorphizing a body from an upstream crate which had an unstable feature
+        // enabled that we do not.
+        //
+        // Note: `feature_bound_holds_in_crate` does not consider a feature to be enabled
+        // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
+        if self.cx().features().feature_bound_holds_in_crate(symbol)
+            || (self.typing_mode() == TypingMode::PostAnalysis)
+        {
+            return self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes);
+        } else {
+            return self.evaluate_added_goals_and_make_canonical_response(Certainty::Maybe(
+                MaybeCause::Ambiguity,
+            ));
+        }
     }
 
     #[instrument(level = "trace", skip(self))]

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -774,18 +774,20 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         }
                     }
 
-                     // During codegen we must assume that all feature bounds hold as we may be
-                     // monomorphizing a body from an upstream crate which had an unstable feature
-                     // enabled that we do not.
-                     //
-                     // Note: we don't consider a feature to be enabled
-                     // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
-                     if (!self.selcx.tcx().features().staged_api() && self.selcx.tcx().features().enabled(symbol))
-                         || (self.selcx.infcx.typing_mode() == TypingMode::PostAnalysis) {
-                         return ProcessResult::Changed(Default::default());
-                     } else {
-                          return ProcessResult::Unchanged;
-                     }
+                    // During codegen we must assume that all feature bounds hold as we may be
+                    // monomorphizing a body from an upstream crate which had an unstable feature
+                    // enabled that we do not.
+                    //
+                    // Note: we don't consider a feature to be enabled
+                    // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
+                    if (!self.selcx.tcx().features().staged_api()
+                        && self.selcx.tcx().features().enabled(symbol))
+                        || (self.selcx.infcx.typing_mode() == TypingMode::PostAnalysis)
+                    {
+                        return ProcessResult::Changed(Default::default());
+                    } else {
+                        return ProcessResult::Unchanged;
+                    }
                 }
             },
         }

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -854,13 +854,14 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                     //
                     // Note: we don't not consider a feature to be enabled
                     // if we are in std/core even if there is a corresponding `feature` attribute on the crate.
-                    if (!self.tcx().features().staged_api() && self.tcx().features().enabled(symbol))
-                        || (self.infcx.typing_mode() == TypingMode::PostAnalysis) {
-                         return Ok(EvaluatedToOk);
+                    if (!self.tcx().features().staged_api()
+                        && self.tcx().features().enabled(symbol))
+                        || (self.infcx.typing_mode() == TypingMode::PostAnalysis)
+                    {
+                        return Ok(EvaluatedToOk);
                     } else {
-                         return Ok(EvaluatedToAmbig);
+                        return Ok(EvaluatedToAmbig);
                     }
-
                 }
 
                 ty::PredicateKind::Clause(ty::ClauseKind::ConstEvaluatable(uv)) => {

compiler/rustc_type_ir/src/flags.rs

@@ -409,8 +409,8 @@ impl<I: Interner> FlagComputation<I> {
                 self.add_term(t1);
                 self.add_term(t2);
             }
-            ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_sym))
-            | ty::PredicateKind::Ambiguous => {}
+            ty::PredicateKind::Clause(ty::ClauseKind::UnstableFeature(_sym)) => {}
+            ty::PredicateKind::Ambiguous => {}
         }
     }