revert

Author: ada4a

clippy_lints/src/significant_drop_tightening.rs

@@ -83,11 +83,11 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
             let emit_sugg = |diag: &mut Diag<'_, _>| match apa.counter {
                 0 | 1 => {},
                 2 => {
-                    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));
+                    if !apa.last_stmt_span.is_dummy() {
+                        if !apa.last_method_span.is_dummy() {
+                            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 usage_method = snippet(cx, apa.last_method_span, "..");
                             let stmt = if let Some(last_bind_ident) = apa.last_bind_ident {
                                 format!(
                                     "\n{indent}let {} = {init_method}.{usage_method};",
@@ -98,23 +98,23 @@ impl<'tcx> LateLintPass<'tcx> for SignificantDropTightening<'tcx> {
                             };
                             diag.multipart_suggestion_verbose(
                                 "merge the temporary construction with its single usage",
-                                vec![(apa.first_stmt_span, stmt), (last_stmt_span, String::new())],
+                                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(last_stmt_span, "single usage here");
+                            diag.span_note(apa.last_stmt_span, "single usage here");
                         }
                     }
                 },
                 _ => {
-                    if let Some(last_stmt_span) = apa.last_stmt_span {
+                    if !apa.last_stmt_span.is_dummy() {
                         diag.span_suggestion(
-                            last_stmt_span.shrink_to_hi(),
+                            apa.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)),
+                                " ".repeat(indent_of(cx, apa.last_stmt_span).unwrap_or(0)),
                                 first_bind_ident
                             ),
                             Applicability::MaybeIncorrect,
@@ -238,19 +238,15 @@ 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);
-                // last stmt is not dummy
-                if let Some(last_stmt_span) = apa.last_stmt_span
-                    && !last_stmt_span.is_dummy()
-                    // last stmt is not current
-                    && last_stmt_span != self.ap.curr_stmt.span
-                    && (block_equals_curr || block_is_ancestor)
-                {
+                if last_stmt_is_not_dummy && last_stmt_is_not_curr && (block_equals_curr || block_is_ancestor) {
                     apa.has_expensive_expr_after_last_attr = true;
                 }
             }
@@ -290,10 +286,6 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> {
                 && !self.ap.apas.contains_key(&hir_id)
                 && path_to_local(expr).is_none_or(|local_hir_id| local_hir_id == hir_id)
             {
-                #[expect(
-                    clippy::inconsistent_struct_constructor,
-                    reason = "grouping fields with default values at the end"
-                )]
                 let mut apa = AuxParamsAttr {
                     first_block_hir_id: self.ap.curr_block_hir_id,
                     first_block_span: self.ap.curr_block_span,
@@ -307,12 +299,7 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> {
                         }
                     },
                     first_stmt_span: self.ap.curr_stmt.span,
-                    // default values
-                    counter: 0,
-                    has_expensive_expr_after_last_attr: false,
-                    last_bind_ident: None,
-                    last_method_span: None,
-                    last_stmt_span: None,
+                    ..Default::default()
                 };
                 modify_apa_params(&mut apa);
                 let _ = self.ap.apas.insert(hir_id, apa);
@@ -331,22 +318,22 @@ impl<'tcx> Visitor<'tcx> for StmtsChecker<'_, '_, '_, '_, 'tcx> {
                         if let Some(local_init) = local.init
                             && let hir::ExprKind::MethodCall(_, _, _, span) = local_init.kind
                         {
-                            apa.last_method_span = Some(span);
+                            apa.last_method_span = span;
                         }
                     },
                     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 = None;
+                            apa.last_stmt_span = DUMMY_SP;
                             return;
                         }
                         if let hir::ExprKind::MethodCall(_, _, _, span) = semi_expr.kind {
-                            apa.last_method_span = Some(span);
+                            apa.last_method_span = span;
                         }
                     },
                     _ => {},
                 }
-                apa.last_stmt_span = Some(self.ap.curr_stmt.span);
+                apa.last_stmt_span = self.ap.curr_stmt.span;
                 modify_apa_params(apa);
             }
         }
@@ -402,9 +389,26 @@ struct AuxParamsAttr {
     /// marked with `#[has_significant_drop]`.
     last_bind_ident: Option<Ident>,
     /// Similar to `last_bind_span` but encompasses the right-hand method call.
-    last_method_span: Option<Span>,
+    last_method_span: Span,
     /// Similar to `last_bind_span` but encompasses the whole contained statement.
-    last_stmt_span: Option<Span>,
+    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: DUMMY_SP,
+            last_stmt_span: DUMMY_SP,
+        }
+    }
 }
 
 fn dummy_stmt_expr<'any>(expr: &'any hir::Expr<'any>) -> hir::Stmt<'any> {