Only look at consequtive statements

Author: Henri Lunnikivi

clippy_lints/src/field_reassign_with_default.rs

@@ -50,7 +50,7 @@ impl LateLintPass<'_> for FieldReassignWithDefault {
         // start from the `let mut _ = _::default();` and look at all the following
         // statements, see if they re-assign the fields of the binding
         for (stmt_idx, binding_name, binding_type) in binding_statements_using_default {
-            // last statement of block cannot trigger the lint
+            // the last statement of a block cannot trigger the lint
             if stmt_idx == block.stmts.len() - 1 {
                 break;
             }
@@ -62,28 +62,28 @@ impl LateLintPass<'_> for FieldReassignWithDefault {
             for consequtive_statement in &block.stmts[stmt_idx + 1..] {
                 // interrupt if the statement is a let binding (`Local`) that shadows the original
                 // binding
-                if stmt_shadows_binding(consequtive_statement, &binding_name) {
+                if stmt_shadows_binding(consequtive_statement, binding_name) {
                     break;
                 }
-                // statement kinds other than `StmtKind::Local` are valid, because they cannot
-                // shadow a binding
-                else {
-                    // find out if and which field was set by this `consequtive_statement`
-                    if let Some((field_ident, assign_rhs)) =
-                        field_reassigned_by_stmt(consequtive_statement, &binding_name)
-                    {
-                        // extract and store the assigned value for help message
-                        let value_snippet = snippet(cx, assign_rhs.span, "..");
-
-                        // always re-insert set value, this way the latest value is stored for output snippet
-                        assigned_fields.insert(field_ident.name, value_snippet);
-
-                        // also set first instance of error for help message
-                        if first_assign.is_none() {
-                            first_assign = Some(consequtive_statement);
-                        }
+                // find out if and which field was set by this `consequtive_statement`
+                else if let Some((field_ident, assign_rhs)) =
+                    field_reassigned_by_stmt(consequtive_statement, binding_name)
+                {
+                    // extract and store the assigned value for help message
+                    let value_snippet = snippet(cx, assign_rhs.span, "..");
+
+                    // always re-insert set value, this way the latest value is stored for output snippet
+                    assigned_fields.insert(field_ident.name, value_snippet);
+
+                    // also set first instance of error for help message
+                    if first_assign.is_none() {
+                        first_assign = Some(consequtive_statement);
                     }
                 }
+                // interrupt also if no field was assigned, since we only want to look at consequtive statements
+                else {
+                    break;
+                }
             }
 
             // if there are incorrectly assigned fields, do a span_lint_and_note to suggest
@@ -165,17 +165,17 @@ fn enumerate_bindings_using_default<'cx, 'hir>(
         .collect()
 }
 
-fn stmt_shadows_binding(this: &Stmt<'_>, shadowed: &Symbol) -> bool {
+fn stmt_shadows_binding(this: &Stmt<'_>, shadowed: Symbol) -> bool {
     if let StmtKind::Local(local) = &this.kind {
         if let PatKind::Binding(_, _, ident, _) = local.pat.kind {
-            return &ident.name == shadowed;
+            return ident.name == shadowed;
         }
     }
     false
 }
 
 /// Returns the reassigned field and the assigning expression (right-hand side of assign).
-fn field_reassigned_by_stmt<'hir>(this: &Stmt<'hir>, binding_name: &Symbol) -> Option<(Ident, &'hir Expr<'hir>)> {
+fn field_reassigned_by_stmt<'hir>(this: &Stmt<'hir>, binding_name: Symbol) -> Option<(Ident, &'hir Expr<'hir>)> {
     if_chain! {
         // only take assignments
         if let StmtKind::Semi(ref later_expr) = this.kind;
@@ -186,7 +186,7 @@ fn field_reassigned_by_stmt<'hir>(this: &Stmt<'hir>, binding_name: &Symbol) -> O
         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;
+        if second_binding_name.ident.name == binding_name;
         then {
             Some((field_ident, assign_rhs))
         } else {
@@ -200,7 +200,7 @@ fn fields_of_type<'a>(ty: &'a TyS<'_>) -> Vec<Ident> {
     if let Adt(adt, _) = ty.kind() {
         if adt.is_struct() {
             // unwrap is safe, because this is a struct and structs have only one variant
-            let variant = &adt.variants.get(0usize.into()).unwrap();
+            let variant = &adt.variants.get(0_usize.into()).unwrap();
             return variant.fields.iter().map(|f| f.ident).collect();
         }
     }