fmt

Author: tiif

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -2370,10 +2370,10 @@ impl<'tcx> WfCheckingCtxt<'_, 'tcx> {
             // We lower empty bounds like `Vec<dyn Copy>:` as
             // `WellFormed(Vec<dyn Copy>)`, which will later get checked by
             // regular WF checking
-            
+
             match pred.kind().skip_binder() {
                 ty::ClauseKind::WellFormed(..) | ty::ClauseKind::UnstableFeature(..) => continue,
-                _ => {},
+                _ => {}
             }
 
             // Match the existing behavior.

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -1,6 +1,7 @@
 use std::assert_matches::assert_matches;
 
 use hir::Node;
+use rustc_attr_data_structures::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir as hir;
 use rustc_hir::def::DefKind;
@@ -18,9 +19,6 @@ use crate::constrained_generic_params as cgp;
 use crate::delegation::inherit_predicates_for_delegation_item;
 use crate::hir_ty_lowering::{HirTyLowerer, PredicateFilter, RegionInferReason};
 
-
-use rustc_attr_data_structures::{AttributeKind, find_attr};
-
 /// Returns a list of all type predicates (explicit and implicit) for the definition with
 /// ID `def_id`. This includes all predicates returned by `explicit_predicates_of`, plus
 /// inferred constraints concerning which regions outlive other regions.
@@ -328,11 +326,8 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             .unwrap_or_default();
 
     for (feat_name, span) in allow_unstable_feature_attr {
-        predicates.insert((
-            ty::ClauseKind::UnstableFeature(*feat_name).upcast(tcx),
-            *span
-        ));
-    } 
+        predicates.insert((ty::ClauseKind::UnstableFeature(*feat_name).upcast(tcx), *span));
+    }
 
     let mut predicates: Vec<_> = predicates.into_iter().collect();
 

compiler/rustc_passes/src/stability.rs

@@ -801,28 +801,28 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                     // FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
                     let const_stab = attrs::find_attr!(attrs, AttributeKind::ConstStability{stability, ..} => *stability);
 
-                    let unstable_feature_stab =  
+                    let unstable_feature_stab =
                         find_attr!(attrs, AttributeKind::AllowUnstableFeature(i) => i)
-                        .map(|i| i.as_slice())
-                        .unwrap_or_default();
+                            .map(|i| i.as_slice())
+                            .unwrap_or_default();
 
                     // If this impl block has an #[unstable] attribute, give an
                     // error if all involved types and traits are stable, because
                     // it will have no effect.
                     // See: https://github.com/rust-lang/rust/issues/55436
                     //
                     // The exception is when there is both  #[unstable_feature_bound(..)] and
-                    //  #![unstable(feature = "..", issue = "..")] that have the same symbol because 
+                    //  #![unstable(feature = "..", issue = "..")] that have the same symbol because
                     // that can effectively mark an impl as unstable.
                     //
                     // For example:
                     // ```
-                    // #[unstable_feature_bound(feat_foo)] 
+                    // #[unstable_feature_bound(feat_foo)]
                     // #![unstable(feature = "feat_foo", issue = "none")]
                     // impl Foo for Bar {}
                     // ```
                     if let Some((
-                        Stability { level: attrs::StabilityLevel::Unstable { ..}, feature},
+                        Stability { level: attrs::StabilityLevel::Unstable { .. }, feature },
                         span,
                     )) = stab
                     {
@@ -831,7 +831,7 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                         c.visit_trait_ref(t);
 
                         // Skip the lint if the impl is marked as unstable using
-                        // #[unstable_feature_bound(..)] 
+                        // #[unstable_feature_bound(..)]
                         let mut unstable_feature_bound_in_effect = false;
                         for (unstable_bound_feat_name, _) in unstable_feature_stab {
                             if *unstable_bound_feat_name == feature {
@@ -841,7 +841,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
 
                         // do not lint when the trait isn't resolved, since resolution error should
                         // be fixed first
-                        if t.path.res != Res::Err && c.fully_stable && !unstable_feature_bound_in_effect {
+                        if t.path.res != Res::Err
+                            && c.fully_stable
+                            && !unstable_feature_bound_in_effect
+                        {
                             self.tcx.emit_node_span_lint(
                                 INEFFECTIVE_UNSTABLE_TRAIT_IMPL,
                                 item.hir_id(),

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -778,7 +778,7 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         // If we are in std/core, and the feature is not enabled through #[unstable_feature_bound(..)].
                         return ProcessResult::Unchanged;
                     } else {
-                        // Outside of std/core, check if feature is enabled at crate level with #[feature(..)] 
+                        // Outside of std/core, check if feature is enabled at crate level with #[feature(..)]
                         // or if we are currently in codegen.
                         if self.selcx.tcx().features().enabled(symbol)
                             || (self.selcx.infcx.typing_mode() == TypingMode::PostAnalysis)
@@ -787,7 +787,6 @@ impl<'a, 'tcx> ObligationProcessor for FulfillProcessor<'a, 'tcx> {
                         } else {
                             return ProcessResult::Unchanged;
                         }
-
                     }
                 }
             },

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

@@ -851,7 +851,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         // If we are in std/core, and the feature is not enabled through #[unstable_feature_bound(..)].
                         return Ok(EvaluatedToAmbig);
                     } else {
-                        // Outside of std/core, check if feature is enabled at crate level with #[feature(..)] 
+                        // Outside of std/core, check if feature is enabled at crate level with #[feature(..)]
                         // or if we are currently in codegen.
                         if self.tcx().features().enabled(symbol)
                             || (self.infcx.typing_mode() == TypingMode::PostAnalysis)