Switch to LateLintPass

Author: Henri Lunnikivi

clippy_lints/src/field_reassign_with_default.rs

@@ -1,10 +1,12 @@
-use crate::utils::{match_path_ast, paths, snippet, span_lint_and_note};
+use crate::utils::{match_def_path, paths, qpath_res, snippet, span_lint_and_note};
 use if_chain::if_chain;
-use rustc_ast::ast::{Block, ExprKind, PatKind, StmtKind};
-use rustc_lint::{EarlyContext, EarlyLintPass};
-use rustc_session::{declare_lint_pass, declare_tool_lint};
+use rustc_hir::def::Res;
+use rustc_hir::{Block, ExprKind, PatKind, QPath, StmtKind};
 use rustc_span::symbol::Symbol;
 
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::{declare_lint_pass, declare_tool_lint};
+
 declare_clippy_lint! {
     /// **What it does:** Checks for immediate reassignment of fields initialized
     /// with Default::default().
@@ -13,19 +15,18 @@ declare_clippy_lint! {
     /// T { field: value, ..Default::default() } syntax instead of using a mutable binding.
     ///
     /// **Known problems:** The lint does not detect calls to Default::default()
-    /// if they are made via another struct implementing the Default trait. This
-    /// may be corrected with a LateLintPass. If type inference stops requiring
-    /// an explicit type for assignment using Default::default() this lint will
-    /// not trigger for cases where the type is elided. This may also be corrected
-    /// with a LateLintPass.
+    /// if they are made via another struct implementing the Default trait. If type inference stops
+    /// requiring an explicit type for assignment using Default::default() this lint will not
+    /// trigger for cases where the type is elided.
     ///
     /// **Example:**
+    /// Bad:
     /// ```ignore
-    /// // Bad
     /// let mut a: A = Default::default();
     /// a.i = 42;
-    ///
-    /// // Good
+    /// ```
+    /// Use instead:
+    /// ```ignore
     /// let a = A {
     ///     i: 42,
     ///     .. Default::default()
@@ -38,8 +39,8 @@ declare_clippy_lint! {
 
 declare_lint_pass!(FieldReassignWithDefault => [FIELD_REASSIGN_WITH_DEFAULT]);
 
-impl EarlyLintPass for FieldReassignWithDefault {
-    fn check_block(&mut self, cx: &EarlyContext<'_>, block: &Block) {
+impl LateLintPass<'_> for FieldReassignWithDefault {
+    fn check_block(&mut self, cx: &LateContext<'_>, block: &Block<'_>) {
         // store statement index and name of binding for all statements like
         // `let mut binding = Default::default();`
         let binding_statements_using_default: Vec<(usize, Symbol)> = block
@@ -51,15 +52,16 @@ impl EarlyLintPass for FieldReassignWithDefault {
                     // only take `let ...` statements
                     if let StmtKind::Local(ref local) = stmt.kind;
                     // only take bindings to identifiers
-                    if let PatKind::Ident(_, binding, _) = local.pat.kind;
+                    if let PatKind::Binding(_, _, ident, _) = local.pat.kind;
                     // only when assigning `... = Default::default()`
                     if let Some(ref expr) = local.init;
                     if let ExprKind::Call(ref fn_expr, _) = &expr.kind;
-                    if let ExprKind::Path( _, path ) = &fn_expr.kind;
+                    if let ExprKind::Path( qpath ) = &fn_expr.kind;
+                    if let Res::Def(_, def_id) = qpath_res(cx, qpath, fn_expr.hir_id);
                     // right hand side of assignment is `Default::default`
-                    if match_path_ast(&path, &paths::DEFAULT_TRAIT_METHOD);
+                    if match_def_path(cx, def_id, &paths::DEFAULT_TRAIT_METHOD);
                     then {
-                        Some((idx, binding.name))
+                        Some((idx, ident.name))
                     }
                     else {
                         None
@@ -84,8 +86,8 @@ impl EarlyLintPass for FieldReassignWithDefault {
                 // interrupt if the statement is a let binding (`Local`) that shadows the original
                 // binding
                 if let StmtKind::Local(local) = &post_defassign_stmt.kind {
-                    if let PatKind::Ident(_, id, _) = local.pat.kind {
-                        if id.name == binding_name {
+                    if let PatKind::Binding(_, _, ident, _) = local.pat.kind {
+                        if ident.name == binding_name {
                             break;
                         }
                     }
@@ -100,7 +102,8 @@ impl EarlyLintPass for FieldReassignWithDefault {
                         // only take assignments to fields where the left-hand side field is a field of
                         // the same binding as the previous statement
                         if let ExprKind::Field(ref binding, later_field_ident) = assign_lhs.kind;
-                        if let ExprKind::Path( _, ref path ) = binding.kind;
+                        if let ExprKind::Path(ref qpath) = binding.kind;
+                        if let QPath::Resolved(_, path) = qpath;
                         if let Some(second_binding_name) = path.segments.last();
                         if second_binding_name.ident.name == binding_name;
                         then {

clippy_lints/src/lib.rs

@@ -1052,7 +1052,7 @@ pub fn register_plugins(store: &mut rustc_lint::LintStore, sess: &Session, conf:
     let enum_variant_name_threshold = conf.enum_variant_name_threshold;
     store.register_early_pass(move || box enum_variants::EnumVariantNames::new(enum_variant_name_threshold));
     store.register_early_pass(|| box tabs_in_doc_comments::TabsInDocComments);
-    store.register_early_pass(|| box field_reassign_with_default::FieldReassignWithDefault);
+    store.register_late_pass(|| box field_reassign_with_default::FieldReassignWithDefault);
     store.register_late_pass(|| box unused_self::UnusedSelf);
     store.register_late_pass(|| box mutable_debug_assertion::DebugAssertWithMutCall);
     store.register_late_pass(|| box exit::Exit);