make AuxParamsAttr.last_stmt_span optional as well

Not related to the previous change per se, just noticed that this field
follows the same `DUMMY_SP` pattern.

And now it doesn't make sense anymore to have the `Default` impl: the
only place it was used in--initialization of an `AuxParamAttr`--already
initializes the really non-defaultable fields (those with types `Span`
and `HirId`), so it's easier to fill in the rest manually

Author: ada4a

clippy_lints/src/significant_drop_tightening.rs

@@ -83,40 +83,43 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
             let emit_sugg = |diag: &mut Diag<'_, _>| match apa.counter {
                 0 | 1 => {},
                 2 => {
-                    if let Some(last_method_span) = apa.last_method_span {
-                        let indent = " ".repeat(indent_of(cx, apa.last_stmt_span).unwrap_or(0));
-                        let init_method = snippet(cx, apa.first_method_span, "..");
-                        let usage_method = snippet(cx, last_method_span, "..");
-                        let stmt = if let Some(last_bind_ident) = apa.last_bind_ident {
-                            format!(
-                                "\n{indent}let {} = {init_method}.{usage_method};",
-                                snippet(cx, last_bind_ident.span, ".."),
-                            )
+                    if let Some(last_stmt_span) = apa.last_stmt_span {
+                        if let Some(last_method_span) = apa.last_method_span {
+                            let indent = " ".repeat(indent_of(cx, last_stmt_span).unwrap_or(0));
+                            let init_method = snippet(cx, apa.first_method_span, "..");
+                            let usage_method = snippet(cx, last_method_span, "..");
+                            let stmt = if let Some(last_bind_ident) = apa.last_bind_ident {
+                                format!(
+                                    "\n{indent}let {} = {init_method}.{usage_method};",
+                                    snippet(cx, last_bind_ident.span, ".."),
+                                )
+                            } else {
+                                format!("\n{indent}{init_method}.{usage_method};")
+                            };
+                            diag.multipart_suggestion_verbose(
+                                "merge the temporary construction with its single usage",
+                                vec![(apa.first_stmt_span, stmt), (last_stmt_span, String::new())],
+                                Applicability::MaybeIncorrect,
+                            );
                         } else {
-                            format!("\n{indent}{init_method}.{usage_method};")
-                        };
-
-                        diag.multipart_suggestion_verbose(
-                            "merge the temporary construction with its single usage",
-                            vec![(apa.first_stmt_span, stmt), (apa.last_stmt_span, String::new())],
-                            Applicability::MaybeIncorrect,
-                        );
-                    } else {
-                        diag.help("merge the temporary construction with its single usage");
-                        diag.span_note(apa.last_stmt_span, "single usage here");
+                            diag.help("merge the temporary construction with its single usage");
+                            diag.span_note(last_stmt_span, "single usage here");
+                        }
                     }
                 },
                 _ => {
-                    diag.span_suggestion(
-                        apa.last_stmt_span.shrink_to_hi(),
-                        "drop the temporary after the end of its last usage",
-                        format!(
-                            "\n{}drop({});",
-                            " ".repeat(indent_of(cx, apa.last_stmt_span).unwrap_or(0)),
-                            first_bind_ident
-                        ),
-                        Applicability::MaybeIncorrect,
-                    );
+                    if let Some(last_stmt_span) = apa.last_stmt_span {
+                        diag.span_suggestion(
+                            last_stmt_span.shrink_to_hi(),
+                            "drop the temporary after the end of its last usage",
+                            format!(
+                                "\n{}drop({});",
+                                " ".repeat(indent_of(cx, last_stmt_span).unwrap_or(0)),
+                                first_bind_ident
+                            ),
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
                 },
             };
             span_lint_and_then(
@@ -235,15 +238,18 @@ impl<'ap, 'lc, 'others, 'stmt, 'tcx> StmtsChecker<'ap, 'lc, 'others, 'stmt, 'tcx
         };
         if has_expensive_stmt {
             for apa in self.ap.apas.values_mut() {
-                let last_stmt_is_not_dummy = apa.last_stmt_span != DUMMY_SP;
-                let last_stmt_is_not_curr = self.ap.curr_stmt.span != apa.last_stmt_span;
                 let block_equals_curr = self.ap.curr_block_hir_id == apa.first_block_hir_id;
                 let block_is_ancestor = self
                     .cx
                     .tcx
                     .hir_parent_iter(self.ap.curr_block_hir_id)
                     .any(|(id, _)| id == apa.first_block_hir_id);
-                if last_stmt_is_not_dummy && last_stmt_is_not_curr && (block_equals_curr || block_is_ancestor) {
+                // last stmt is not dummy
+                if let Some(last_stmt_span) = apa.last_stmt_span
+                    // last stmt is not current
+                    && last_stmt_span != self.ap.curr_stmt.span
+                    && (block_equals_curr || block_is_ancestor)
+                {
                     apa.has_expensive_expr_after_last_attr = true;
                 }
             }
@@ -296,7 +302,12 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> {
                         }
                     },
                     first_stmt_span: self.ap.curr_stmt.span,
-                    ..Default::default()
+                    // default values
+                    counter: 0,
+                    has_expensive_expr_after_last_attr: false,
+                    last_bind_ident: None,
+                    last_method_span: None,
+                    last_stmt_span: None,
                 };
                 modify_apa_params(&mut apa);
                 let _ = self.ap.apas.insert(hir_id, apa);
@@ -321,7 +332,7 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> {
                     hir::StmtKind::Semi(semi_expr) => {
                         if has_drop(semi_expr, apa.first_bind_ident, self.cx) {
                             apa.has_expensive_expr_after_last_attr = false;
-                            apa.last_stmt_span = DUMMY_SP;
+                            apa.last_stmt_span = None;
                             return;
                         }
                         if let hir::ExprKind::MethodCall(_, _, _, span) = semi_expr.kind {
@@ -330,7 +341,7 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> {
                     },
                     _ => {},
                 }
-                apa.last_stmt_span = self.ap.curr_stmt.span;
+                apa.last_stmt_span = Some(self.ap.curr_stmt.span);
                 modify_apa_params(apa);
             }
         }
@@ -388,24 +399,7 @@ struct AuxParamsAttr {
     /// Similar to `last_bind_span` but encompasses the right-hand method call.
     last_method_span: Option<Span>,
     /// Similar to `last_bind_span` but encompasses the whole contained statement.
-    last_stmt_span: Span,
-}
-
-impl Default for AuxParamsAttr {
-    fn default() -> Self {
-        Self {
-            counter: 0,
-            has_expensive_expr_after_last_attr: false,
-            first_block_hir_id: HirId::INVALID,
-            first_block_span: DUMMY_SP,
-            first_bind_ident: None,
-            first_method_span: DUMMY_SP,
-            first_stmt_span: DUMMY_SP,
-            last_bind_ident: None,
-            last_method_span: None,
-            last_stmt_span: DUMMY_SP,
-        }
-    }
+    last_stmt_span: Option<Span>,
 }
 
 fn dummy_stmt_expr<'any>(expr: &'any hir::Expr<'any>) -> hir::Stmt<'any> {