address review

Author: Kivooeo

compiler/rustc_hir_typeck/src/errors.rs

@@ -7,7 +7,7 @@ use rustc_ast::{AssignOpKind, Label};
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, DiagArgValue, DiagCtxtHandle, DiagSymbolList, Diagnostic,
-    EmissionGuarantee, IntoDiagArg, Level, MultiSpan, Subdiagnostic, struct_span_code_err,
+    EmissionGuarantee, IntoDiagArg, Level, MultiSpan, Subdiagnostic,
 };
 use rustc_hir as hir;
 use rustc_hir::ExprKind;
@@ -1146,13 +1146,16 @@ pub(crate) fn maybe_emit_plus_equals_diagnostic<'a>(
         && let hir::ExprKind::Path(hir::QPath::Resolved(_, path)) = &right.kind
         && matches!(path.res, hir::def::Res::Local(_))
     {
-        let mut err = struct_span_code_err!(
-            fnctxt.dcx(),
+        let mut err = fnctxt.dcx().struct_span_err(
             assign_op.span,
-            E0368,
             "binary assignment operation `+=` cannot be used in a let chain",
         );
 
+        err.span_label(
+            lhs_expr.span,
+            "you are add-assigning the right-hand side expression to the result of this let-chain",
+        );
+
         err.span_label(assign_op.span, "cannot use `+=` in a let chain");
 
         err.span_suggestion(

compiler/rustc_hir_typeck/src/expr.rs

@@ -48,6 +48,7 @@ use crate::errors::{
     NoFieldOnVariant, ReturnLikeStatementKind, ReturnStmtOutsideOfFnBody, StructExprNonExhaustive,
     TypeMismatchFruTypo, YieldExprOutsideOfCoroutine,
 };
+use crate::op::contains_let_in_chain;
 use crate::{
     BreakableCtxt, CoroutineTypes, Diverges, FnCtxt, GatherLocalsVisitor, Needs,
     TupleArgumentsFlag, cast, fatally_break_rust, report_unexpected_variant_res, type_error_struct,
@@ -1251,7 +1252,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // Skip suggestion if LHS contains a let-chain at this would likely be spurious
         // cc: https://github.com/rust-lang/rust/issues/147664
-        if crate::op::contains_let_in_chain(lhs) {
+        if contains_let_in_chain(lhs) {
             return;
         }
 

tests/ui/parser/let-chains-assign-add-incorrect.fixed

@@ -0,0 +1,36 @@
+//@ edition:2024
+//@ run-rustfix
+
+#![allow(irrefutable_let_patterns)]
+
+fn test_where_left_is_not_let() {
+    let y = 2;
+    if let _ = 1 && true && y == 2 {};
+    //~^ ERROR expected expression, found `let` statement
+    //~| NOTE only supported directly in conditions of `if` and `while` expressions
+    //~| ERROR mismatched types
+    //~| NOTE expected `bool`, found integer
+    //~| NOTE you are add-assigning the right-hand side expression to the result of this let-chain
+    //~| NOTE expected because this is `bool`
+    //~| ERROR binary assignment operation `+=` cannot be used in a let chain
+    //~| NOTE cannot use `+=` in a let chain
+    //~| HELP you might have meant to compare with `==` instead of assigning with `+=`
+}
+
+fn test_where_left_is_let() {
+    let y = 2;
+    if let _ = 1 && y == 2 {};
+    //~^ ERROR expected expression, found `let` statement
+    //~| NOTE only supported directly in conditions of `if` and `while` expressions
+    //~| ERROR mismatched types
+    //~| NOTE expected `bool`, found integer
+    //~| NOTE you are add-assigning the right-hand side expression to the result of this let-chain
+    //~| ERROR binary assignment operation `+=` cannot be used in a let chain
+    //~| NOTE cannot use `+=` in a let chain
+    //~| HELP you might have meant to compare with `==` instead of assigning with `+=`
+}
+
+fn main() {
+    test_where_left_is_let();
+    test_where_left_is_not_let()
+}

tests/ui/parser/let-chains-assign-add-incorrect.rs

@@ -1,28 +1,36 @@
 //@ edition:2024
+//@ run-rustfix
+
+#![allow(irrefutable_let_patterns)]
 
 fn test_where_left_is_not_let() {
-    let mut y = 2;
-    if let x = 1 && true && y += 2 {};
+    let y = 2;
+    if let _ = 1 && true && y += 2 {};
     //~^ ERROR expected expression, found `let` statement
     //~| NOTE only supported directly in conditions of `if` and `while` expressions
     //~| ERROR mismatched types
     //~| NOTE expected `bool`, found integer
+    //~| NOTE you are add-assigning the right-hand side expression to the result of this let-chain
     //~| NOTE expected because this is `bool`
     //~| ERROR binary assignment operation `+=` cannot be used in a let chain
     //~| NOTE cannot use `+=` in a let chain
     //~| HELP you might have meant to compare with `==` instead of assigning with `+=`
 }
 
 fn test_where_left_is_let() {
-    let mut y = 2;
-    if let x = 1 && y += 2 {};
+    let y = 2;
+    if let _ = 1 && y += 2 {};
     //~^ ERROR expected expression, found `let` statement
     //~| NOTE only supported directly in conditions of `if` and `while` expressions
     //~| ERROR mismatched types
     //~| NOTE expected `bool`, found integer
+    //~| NOTE you are add-assigning the right-hand side expression to the result of this let-chain
     //~| ERROR binary assignment operation `+=` cannot be used in a let chain
     //~| NOTE cannot use `+=` in a let chain
     //~| HELP you might have meant to compare with `==` instead of assigning with `+=`
 }
 
-fn main() {}
+fn main() {
+    test_where_left_is_let();
+    test_where_left_is_not_let()
+}

tests/ui/parser/let-chains-assign-add-incorrect.stderr

@@ -1,58 +1,61 @@
 error: expected expression, found `let` statement
-  --> $DIR/let-chains-assign-add-incorrect.rs:5:8
+  --> $DIR/let-chains-assign-add-incorrect.rs:8:8
    |
-LL |     if let x = 1 && true && y += 2 {};
+LL |     if let _ = 1 && true && y += 2 {};
    |        ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 
 error: expected expression, found `let` statement
-  --> $DIR/let-chains-assign-add-incorrect.rs:18:8
+  --> $DIR/let-chains-assign-add-incorrect.rs:22:8
    |
-LL |     if let x = 1 && y += 2 {};
+LL |     if let _ = 1 && y += 2 {};
    |        ^^^^^^^^^
    |
    = note: only supported directly in conditions of `if` and `while` expressions
 
 error[E0308]: mismatched types
-  --> $DIR/let-chains-assign-add-incorrect.rs:5:29
+  --> $DIR/let-chains-assign-add-incorrect.rs:8:29
    |
-LL |     if let x = 1 && true && y += 2 {};
+LL |     if let _ = 1 && true && y += 2 {};
    |        -----------------    ^ expected `bool`, found integer
    |        |
    |        expected because this is `bool`
 
-error[E0368]: binary assignment operation `+=` cannot be used in a let chain
-  --> $DIR/let-chains-assign-add-incorrect.rs:5:31
+error: binary assignment operation `+=` cannot be used in a let chain
+  --> $DIR/let-chains-assign-add-incorrect.rs:8:31
    |
-LL |     if let x = 1 && true && y += 2 {};
-   |                               ^^ cannot use `+=` in a let chain
+LL |     if let _ = 1 && true && y += 2 {};
+   |        ---------------------- ^^ cannot use `+=` in a let chain
+   |        |
+   |        you are add-assigning the right-hand side expression to the result of this let-chain
    |
 help: you might have meant to compare with `==` instead of assigning with `+=`
    |
-LL -     if let x = 1 && true && y += 2 {};
-LL +     if let x = 1 && true && y == 2 {};
+LL -     if let _ = 1 && true && y += 2 {};
+LL +     if let _ = 1 && true && y == 2 {};
    |
 
 error[E0308]: mismatched types
-  --> $DIR/let-chains-assign-add-incorrect.rs:18:21
+  --> $DIR/let-chains-assign-add-incorrect.rs:22:21
    |
-LL |     if let x = 1 && y += 2 {};
+LL |     if let _ = 1 && y += 2 {};
    |                     ^ expected `bool`, found integer
 
-error[E0368]: binary assignment operation `+=` cannot be used in a let chain
-  --> $DIR/let-chains-assign-add-incorrect.rs:18:23
+error: binary assignment operation `+=` cannot be used in a let chain
+  --> $DIR/let-chains-assign-add-incorrect.rs:22:23
    |
-LL |     if let x = 1 && y += 2 {};
-   |                       ^^ cannot use `+=` in a let chain
+LL |     if let _ = 1 && y += 2 {};
+   |        -------------- ^^ cannot use `+=` in a let chain
+   |        |
+   |        you are add-assigning the right-hand side expression to the result of this let-chain
    |
 help: you might have meant to compare with `==` instead of assigning with `+=`
    |
-LL -     if let x = 1 && y += 2 {};
-LL +     if let x = 1 && y == 2 {};
+LL -     if let _ = 1 && y += 2 {};
+LL +     if let _ = 1 && y == 2 {};
    |
 
 error: aborting due to 6 previous errors
 
-Some errors have detailed explanations: E0308, E0368.
-For more information about an error, try `rustc --explain E0308`.
+For more information about this error, try `rustc --explain E0308`.