From af73147adb7b40744f1e30b282bbba85f2734365 Mon Sep 17 00:00:00 2001
From: Denis Bezrukov <6227442+denbezrukov@users.noreply.github.com>
Date: Sun, 14 May 2023 19:32:20 +0300
Subject: [PATCH] fix(rome_js_analyze): Files with fn(() => (aborted = true));
 cause - entered unreachable code - when --apply-unsafe #4464

---
 CHANGELOG.md                                  |   1 +
 crates/rome_cli/tests/commands/check.rs       |  32 ++
 .../apply_unsafe_no_assign_in_expression.snap |  18 +
 .../suspicious/no_assign_in_expressions.rs    | 374 +++++++++++++++++-
 .../noAssignInExpressions/invalid.js          |   5 +-
 .../noAssignInExpressions/invalid.js.snap     | 352 +++++++++--------
 6 files changed, 611 insertions(+), 171 deletions(-)
 create mode 100644 crates/rome_cli/tests/snapshots/main_commands_check/apply_unsafe_no_assign_in_expression.snap

diff --git a/CHANGELOG.md b/CHANGELOG.md
index bbc823b96e0..ae8877fc64e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@
 ### Editors
 ### Formatter
 ### Linter
+- Fixed an issue where the `noAssignInExpressions` rule replaced the operator with an invalid token, which caused other lint rules to crash. [#4464](https://github.com/rome/tools/issues/4464)
 ### Parser
 ### VSCode
 ### JavaScript APIs
diff --git a/crates/rome_cli/tests/commands/check.rs b/crates/rome_cli/tests/commands/check.rs
index e830cd92d6e..754d066a1b8 100644
--- a/crates/rome_cli/tests/commands/check.rs
+++ b/crates/rome_cli/tests/commands/check.rs
@@ -2080,3 +2080,35 @@ fn should_apply_correct_file_source() {
         result,
     ));
 }
+
+#[test]
+fn apply_unsafe_no_assign_in_expression() {
+    let mut fs = MemoryFileSystem::default();
+    let mut console = BufferConsole::default();
+
+    let file_path = Path::new("fix.js");
+    fs.insert(
+        file_path.into(),
+        "res.onAborted(() => (aborted = true));".as_bytes(),
+    );
+
+    let result = run_cli(
+        DynRef::Borrowed(&mut fs),
+        &mut console,
+        Args::from(&[
+            ("check"),
+            file_path.as_os_str().to_str().unwrap(),
+            ("--apply-unsafe"),
+        ]),
+    );
+
+    assert!(result.is_ok(), "run_cli returned {result:?}");
+
+    assert_cli_snapshot(SnapshotPayload::new(
+        module_path!(),
+        "apply_unsafe_no_assign_in_expression",
+        fs,
+        console,
+        result,
+    ));
+}
diff --git a/crates/rome_cli/tests/snapshots/main_commands_check/apply_unsafe_no_assign_in_expression.snap b/crates/rome_cli/tests/snapshots/main_commands_check/apply_unsafe_no_assign_in_expression.snap
new file mode 100644
index 00000000000..ea1ea59d5ac
--- /dev/null
+++ b/crates/rome_cli/tests/snapshots/main_commands_check/apply_unsafe_no_assign_in_expression.snap
@@ -0,0 +1,18 @@
+---
+source: crates/rome_cli/tests/snap_test.rs
+expression: content
+---
+## `fix.js`
+
+```js
+res.onAborted(() => aborted === true);
+
+```
+
+# Emitted Messages
+
+```block
+Fixed 1 file(s) in <TIME>
+```
+
+
diff --git a/crates/rome_js_analyze/src/analyzers/suspicious/no_assign_in_expressions.rs b/crates/rome_js_analyze/src/analyzers/suspicious/no_assign_in_expressions.rs
index 4128912f441..271c468e792 100644
--- a/crates/rome_js_analyze/src/analyzers/suspicious/no_assign_in_expressions.rs
+++ b/crates/rome_js_analyze/src/analyzers/suspicious/no_assign_in_expressions.rs
@@ -4,10 +4,24 @@ use rome_console::markup;
 use rome_diagnostics::Applicability;
 use rome_js_factory::make;
 use rome_js_syntax::{
-    JsAssignmentExpression, JsAssignmentOperator, JsExpressionStatement, JsForStatement,
-    JsParenthesizedExpression, JsSequenceExpression, JsSyntaxKind,
+    AnyJsArrayAssignmentPatternElement, AnyJsArrayElement, AnyJsAssignment, AnyJsAssignmentPattern,
+    AnyJsExpression, AnyJsObjectAssignmentPatternMember, AnyJsObjectMember,
+    JsArrayAssignmentPattern, JsArrayAssignmentPatternRestElement,
+    JsArrayAssignmentPatternRestElementFields, JsArrayExpression, JsAssignmentExpression,
+    JsAssignmentOperator, JsAssignmentWithDefault, JsAssignmentWithDefaultFields,
+    JsBogusAssignment, JsBogusExpression, JsComputedMemberAssignment,
+    JsComputedMemberAssignmentFields, JsComputedMemberExpression, JsExpressionStatement,
+    JsForStatement, JsIdentifierAssignment, JsIdentifierExpression, JsObjectAssignmentPattern,
+    JsObjectAssignmentPatternFields, JsObjectAssignmentPatternPropertyFields, JsObjectExpression,
+    JsParenthesizedAssignment, JsParenthesizedAssignmentFields, JsParenthesizedExpression,
+    JsSequenceExpression, JsSpread, JsStaticMemberAssignment, JsStaticMemberAssignmentFields,
+    JsStaticMemberExpression, JsSyntaxElement, JsSyntaxKind, TsAsAssignment, TsAsAssignmentFields,
+    TsAsExpression, TsNonNullAssertionAssignment, TsNonNullAssertionAssignmentFields,
+    TsNonNullAssertionExpression, TsSatisfiesAssignment, TsSatisfiesAssignmentFields,
+    TsSatisfiesExpression, TsTypeAssertionAssignment, TsTypeAssertionAssignmentFields,
+    TsTypeAssertionExpression,
 };
-use rome_rowan::{AstNode, BatchMutationExt};
+use rome_rowan::{AstNode, BatchMutationExt, SyntaxError, SyntaxResult};
 
 use crate::JsRuleAction;
 
@@ -108,10 +122,20 @@ impl Rule for NoAssignInExpressions {
         let assign = ctx.query();
         let op = assign.operator().ok()?;
         if let JsAssignmentOperator::Assign = op {
-            let operator_token = assign.operator_token().ok()?;
-            let new_operator_token = make::token(JsSyntaxKind::EQ3);
             let mut mutation = ctx.root().begin();
-            mutation.replace_token(operator_token, new_operator_token);
+
+            let token = assign.operator_token().ok()?;
+            let binary_expression = make::js_binary_expression(
+                assign.left().ok()?.try_into_expression().ok()?,
+                make::token(JsSyntaxKind::EQ3)
+                    .with_leading_trivia_pieces(token.leading_trivia().pieces())
+                    .with_trailing_trivia_pieces(token.trailing_trivia().pieces()),
+                assign.right().ok()?,
+            );
+            mutation.replace_element(
+                JsSyntaxElement::Node(assign.syntax().clone()),
+                JsSyntaxElement::Node(binary_expression.into_syntax()),
+            );
             Some(JsRuleAction {
                 mutation,
                 applicability: Applicability::MaybeIncorrect,
@@ -123,3 +147,341 @@ impl Rule for NoAssignInExpressions {
         }
     }
 }
+
+trait TryFromAssignment<T>: Sized {
+    fn try_from_assignment(value: T) -> SyntaxResult<Self>;
+}
+
+pub trait TryIntoExpression<T>: Sized {
+    fn try_into_expression(self) -> SyntaxResult<T>;
+}
+
+impl<T, U> TryIntoExpression<U> for T
+where
+    U: TryFromAssignment<T>,
+{
+    fn try_into_expression(self) -> SyntaxResult<U> {
+        U::try_from_assignment(self)
+    }
+}
+
+impl TryFromAssignment<AnyJsAssignment> for AnyJsExpression {
+    fn try_from_assignment(value: AnyJsAssignment) -> SyntaxResult<AnyJsExpression> {
+        let expression = match value {
+            AnyJsAssignment::JsBogusAssignment(assigment) => {
+                AnyJsExpression::JsBogusExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::JsComputedMemberAssignment(assigment) => {
+                AnyJsExpression::JsComputedMemberExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::JsIdentifierAssignment(assigment) => {
+                AnyJsExpression::JsIdentifierExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::JsParenthesizedAssignment(assigment) => {
+                AnyJsExpression::JsParenthesizedExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::JsStaticMemberAssignment(assigment) => {
+                AnyJsExpression::JsStaticMemberExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::TsAsAssignment(assigment) => {
+                AnyJsExpression::TsAsExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::TsNonNullAssertionAssignment(assigment) => {
+                AnyJsExpression::TsNonNullAssertionExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::TsSatisfiesAssignment(assigment) => {
+                AnyJsExpression::TsSatisfiesExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignment::TsTypeAssertionAssignment(assigment) => {
+                AnyJsExpression::TsTypeAssertionExpression(assigment.try_into_expression()?)
+            }
+        };
+
+        Ok(expression)
+    }
+}
+
+impl TryFromAssignment<JsArrayAssignmentPattern> for JsArrayExpression {
+    fn try_from_assignment(value: JsArrayAssignmentPattern) -> SyntaxResult<Self> {
+        let mut elements = Vec::new();
+
+        for element in value.elements() {
+            let element = match element? {
+                AnyJsArrayAssignmentPatternElement::AnyJsAssignmentPattern(assignment) => {
+                    AnyJsArrayElement::AnyJsExpression(assignment.try_into_expression()?)
+                }
+                AnyJsArrayAssignmentPatternElement::JsArrayAssignmentPatternRestElement(
+                    assignment,
+                ) => AnyJsArrayElement::JsSpread(assignment.try_into_expression()?),
+                AnyJsArrayAssignmentPatternElement::JsArrayHole(hole) => {
+                    AnyJsArrayElement::JsArrayHole(hole)
+                }
+                AnyJsArrayAssignmentPatternElement::JsAssignmentWithDefault(assignment) => {
+                    AnyJsArrayElement::AnyJsExpression(AnyJsExpression::JsAssignmentExpression(
+                        assignment.try_into_expression()?,
+                    ))
+                }
+            };
+            elements.push(element);
+        }
+
+        let elements = make::js_array_element_list(elements.into_iter(), None);
+
+        let expression =
+            make::js_array_expression(value.l_brack_token()?, elements, value.r_brack_token()?);
+
+        Ok(expression)
+    }
+}
+
+impl TryFromAssignment<JsArrayAssignmentPatternRestElement> for JsSpread {
+    fn try_from_assignment(value: JsArrayAssignmentPatternRestElement) -> SyntaxResult<JsSpread> {
+        let JsArrayAssignmentPatternRestElementFields {
+            dotdotdot_token,
+            pattern,
+        } = value.as_fields();
+
+        Ok(make::js_spread(
+            dotdotdot_token?,
+            pattern?.try_into_expression()?,
+        ))
+    }
+}
+
+impl TryFromAssignment<JsObjectAssignmentPattern> for JsObjectExpression {
+    fn try_from_assignment(value: JsObjectAssignmentPattern) -> SyntaxResult<JsObjectExpression> {
+        let JsObjectAssignmentPatternFields {
+            l_curly_token,
+            properties,
+            r_curly_token,
+        } = value.as_fields();
+
+        let mut members = Vec::new();
+
+        for property in properties {
+            let member = match property? {
+                AnyJsObjectAssignmentPatternMember::JsBogusAssignment(assigment) => {
+                    AnyJsObjectMember::JsBogusMember(make::js_bogus_member([Some(
+                        JsSyntaxElement::Node(assigment.into_syntax()),
+                    )]))
+                }
+                AnyJsObjectAssignmentPatternMember::JsObjectAssignmentPatternProperty(
+                    assigment,
+                ) => {
+                    let JsObjectAssignmentPatternPropertyFields {
+                        member,
+                        colon_token,
+                        pattern,
+                        init,
+                    } = assigment.as_fields();
+
+                    if init.is_some() {
+                        return Err(SyntaxError::MissingRequiredChild);
+                    } else {
+                        let member = make::js_property_object_member(
+                            member?,
+                            colon_token?,
+                            pattern?.try_into_expression()?,
+                        );
+                        AnyJsObjectMember::JsPropertyObjectMember(member)
+                    }
+                }
+                AnyJsObjectAssignmentPatternMember::JsObjectAssignmentPatternRest(assigment) => {
+                    let spread = make::js_spread(
+                        assigment.dotdotdot_token()?,
+                        assigment.target()?.try_into_expression()?,
+                    );
+                    AnyJsObjectMember::JsSpread(spread)
+                }
+                AnyJsObjectAssignmentPatternMember::JsObjectAssignmentPatternShorthandProperty(
+                    assigment,
+                ) => {
+                    if assigment.init().is_some() {
+                        return Err(SyntaxError::MissingRequiredChild);
+                    } else {
+                        let member = make::js_shorthand_property_object_member(
+                            make::js_reference_identifier(assigment.identifier()?.name_token()?),
+                        );
+                        AnyJsObjectMember::JsShorthandPropertyObjectMember(member)
+                    }
+                }
+            };
+
+            members.push(member);
+        }
+
+        let member_list = make::js_object_member_list(members.into_iter(), None);
+
+        let expression = make::js_object_expression(l_curly_token?, member_list, r_curly_token?);
+
+        Ok(expression)
+    }
+}
+
+impl TryFromAssignment<JsAssignmentWithDefault> for JsAssignmentExpression {
+    fn try_from_assignment(value: JsAssignmentWithDefault) -> SyntaxResult<JsAssignmentExpression> {
+        let JsAssignmentWithDefaultFields {
+            pattern,
+            eq_token,
+            default,
+        } = value.as_fields();
+
+        Ok(make::js_assignment_expression(
+            pattern?, eq_token?, default?,
+        ))
+    }
+}
+
+impl TryFromAssignment<AnyJsAssignmentPattern> for AnyJsExpression {
+    fn try_from_assignment(value: AnyJsAssignmentPattern) -> SyntaxResult<AnyJsExpression> {
+        let expression = match value {
+            AnyJsAssignmentPattern::AnyJsAssignment(assigment) => {
+                assigment.try_into_expression()?
+            }
+            AnyJsAssignmentPattern::JsArrayAssignmentPattern(assigment) => {
+                AnyJsExpression::JsArrayExpression(assigment.try_into_expression()?)
+            }
+            AnyJsAssignmentPattern::JsObjectAssignmentPattern(assigment) => {
+                AnyJsExpression::JsObjectExpression(assigment.try_into_expression()?)
+            }
+        };
+
+        Ok(expression)
+    }
+}
+
+impl TryFromAssignment<JsBogusAssignment> for JsBogusExpression {
+    fn try_from_assignment(value: JsBogusAssignment) -> SyntaxResult<JsBogusExpression> {
+        Ok(make::js_bogus_expression([Some(JsSyntaxElement::Node(
+            value.into_syntax(),
+        ))]))
+    }
+}
+
+impl TryFromAssignment<JsComputedMemberAssignment> for JsComputedMemberExpression {
+    fn try_from_assignment(
+        value: JsComputedMemberAssignment,
+    ) -> SyntaxResult<JsComputedMemberExpression> {
+        let JsComputedMemberAssignmentFields {
+            object,
+            l_brack_token,
+            member,
+            r_brack_token,
+        } = value.as_fields();
+
+        Ok(
+            make::js_computed_member_expression(object?, l_brack_token?, member?, r_brack_token?)
+                .build(),
+        )
+    }
+}
+
+impl TryFromAssignment<JsIdentifierAssignment> for JsIdentifierExpression {
+    fn try_from_assignment(value: JsIdentifierAssignment) -> SyntaxResult<JsIdentifierExpression> {
+        Ok(make::js_identifier_expression(
+            make::js_reference_identifier(value.name_token()?),
+        ))
+    }
+}
+
+impl TryFromAssignment<JsParenthesizedAssignment> for JsParenthesizedExpression {
+    fn try_from_assignment(
+        value: JsParenthesizedAssignment,
+    ) -> SyntaxResult<JsParenthesizedExpression> {
+        let JsParenthesizedAssignmentFields {
+            l_paren_token,
+            assignment,
+            r_paren_token,
+        } = value.as_fields();
+
+        Ok(make::js_parenthesized_expression(
+            l_paren_token?,
+            assignment?.try_into_expression()?,
+            r_paren_token?,
+        ))
+    }
+}
+
+impl TryFromAssignment<JsStaticMemberAssignment> for JsStaticMemberExpression {
+    fn try_from_assignment(
+        value: JsStaticMemberAssignment,
+    ) -> SyntaxResult<JsStaticMemberExpression> {
+        let JsStaticMemberAssignmentFields {
+            object,
+            dot_token,
+            member,
+        } = value.as_fields();
+
+        Ok(make::js_static_member_expression(
+            object?, dot_token?, member?,
+        ))
+    }
+}
+
+impl TryFromAssignment<TsAsAssignment> for TsAsExpression {
+    fn try_from_assignment(value: TsAsAssignment) -> SyntaxResult<TsAsExpression> {
+        let TsAsAssignmentFields {
+            assignment,
+            as_token,
+            ty,
+        } = value.as_fields();
+
+        Ok(make::ts_as_expression(
+            assignment?.try_into_expression()?,
+            as_token?,
+            ty?,
+        ))
+    }
+}
+
+impl TryFromAssignment<TsNonNullAssertionAssignment> for TsNonNullAssertionExpression {
+    fn try_from_assignment(
+        value: TsNonNullAssertionAssignment,
+    ) -> SyntaxResult<TsNonNullAssertionExpression> {
+        let TsNonNullAssertionAssignmentFields {
+            assignment,
+            excl_token,
+        } = value.as_fields();
+
+        Ok(make::ts_non_null_assertion_expression(
+            assignment?.try_into_expression()?,
+            excl_token?,
+        ))
+    }
+}
+
+impl TryFromAssignment<TsSatisfiesAssignment> for TsSatisfiesExpression {
+    fn try_from_assignment(value: TsSatisfiesAssignment) -> SyntaxResult<TsSatisfiesExpression> {
+        let TsSatisfiesAssignmentFields {
+            assignment,
+            satisfies_token,
+            ty,
+        } = value.as_fields();
+
+        Ok(make::ts_satisfies_expression(
+            assignment?.try_into_expression()?,
+            satisfies_token?,
+            ty?,
+        ))
+    }
+}
+
+impl TryFromAssignment<TsTypeAssertionAssignment> for TsTypeAssertionExpression {
+    fn try_from_assignment(
+        value: TsTypeAssertionAssignment,
+    ) -> SyntaxResult<TsTypeAssertionExpression> {
+        let TsTypeAssertionAssignmentFields {
+            l_angle_token,
+            ty,
+            r_angle_token,
+            assignment,
+        } = value.as_fields();
+
+        Ok(make::ts_type_assertion_expression(
+            l_angle_token?,
+            ty?,
+            r_angle_token?,
+            assignment?.try_into_expression()?,
+        ))
+    }
+}
diff --git a/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js b/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js
index 66821e1d1fe..8969b42d338 100644
--- a/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js
+++ b/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js
@@ -78,4 +78,7 @@ switch (foo) {
 		bar();
 }
 
-((3496.29).bkufyydt = 2e308) ? foo : bar;
+((3496.29/*1*/)/*2*/.bkufyydt/*3*/ = /*4*/2e308/*5*/)/*6*/ ? foo : bar;
+
+res.onAborted(() => /*0*/(/*1*/(/*2*/a/*3*/./*4*/b/*5*/)/*6*/ /*7*/ = /*8*/ /*9*/true/*10*/));
+
diff --git a/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js.snap b/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js.snap
index 8c1de34ffbc..8d7a4852a69 100644
--- a/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js.snap
+++ b/crates/rome_js_analyze/tests/specs/suspicious/noAssignInExpressions/invalid.js.snap
@@ -1,6 +1,5 @@
 ---
 source: crates/rome_js_analyze/tests/spec_tests.rs
-assertion_line: 96
 expression: invalid.js
 ---
 # Input
@@ -85,7 +84,10 @@ switch (foo) {
 		bar();
 }
 
-((3496.29).bkufyydt = 2e308) ? foo : bar;
+((3496.29/*1*/)/*2*/.bkufyydt/*3*/ = /*4*/2e308/*5*/)/*6*/ ? foo : bar;
+
+res.onAborted(() => /*0*/(/*1*/(/*2*/a/*3*/./*4*/b/*5*/)/*6*/ /*7*/ = /*8*/ /*9*/true/*10*/));
+
 
 ```
 
@@ -94,17 +96,17 @@ switch (foo) {
 invalid.js:3:3 lint/suspicious/noAssignInExpressions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     1 │ {
     2 │ 	let a;
   > 3 │ 	(a += 1) + 2;
       │ 	 ^^^^^^
     4 │ }
-    5 │ 
-  
+    5 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
 
 ```
 
@@ -112,21 +114,21 @@ invalid.js:3:3 lint/suspicious/noAssignInExpressions ━━━━━━━━━
 invalid.js:8:7 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
      6 │ {
      7 │ 	let a, b;
    > 8 │ 	a = (b /*before*/ = /*after*/ 1) + 1;
        │ 	     ^^^^^^^^^^^^^^^^^^^^^^^^^^
      9 │ }
-    10 │ 
-  
+    10 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     8 │ → a·=·(b·/*before*/·===·/*after*/·1)·+·1;
-      │                      ++                  
+      │                      ++
 
 ```
 
@@ -134,21 +136,21 @@ invalid.js:8:7 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:13:8 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     11 │ {
     12 │ 	let a, b;
   > 13 │ 	a = ((b = 1), a);
        │ 	      ^^^^^
     14 │ }
-    15 │ 
-  
+    15 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     13 │ → a·=·((b·===·1),·a);
-       │            ++        
+       │            ++
 
 ```
 
@@ -156,21 +158,21 @@ invalid.js:13:8 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:18:7 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     16 │ {
     17 │ 	let a, b;
   > 18 │ 	a = (b = 1, b = 2);
        │ 	     ^^^^^
     19 │ }
-    20 │ 
-  
+    20 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     18 │ → a·=·(b·===·1,·b·=·2);
-       │           ++           
+       │           ++
 
 ```
 
@@ -178,21 +180,21 @@ invalid.js:18:7 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:18:14 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     16 │ {
     17 │ 	let a, b;
   > 18 │ 	a = (b = 1, b = 2);
        │ 	            ^^^^^
     19 │ }
-    20 │ 
-  
+    20 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     18 │ → a·=·(b·=·1,·b·===·2);
-       │                  ++    
+       │                  ++
 
 ```
 
@@ -200,21 +202,21 @@ invalid.js:18:14 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:23:17 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     21 │ {
     22 │ 	let a, b;
   > 23 │ 	a = (class {}, b = 2, function() {});
        │ 	               ^^^^^
     24 │ }
-    25 │ 
-  
+    25 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     23 │ → a·=·(class·{},·b·===·2,·function()·{});
-       │                     ++                   
+       │                     ++
 
 ```
 
@@ -222,21 +224,21 @@ invalid.js:23:17 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:28:13 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     26 │ {
     27 │ 	let a;
   > 28 │ 	const b = (a = 0) ? 1 : 0;
        │ 	           ^^^^^
     29 │ }
-    30 │ 
-  
+    30 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     28 │ → const·b·=·(a·===·0)·?·1·:·0;
-       │                 ++            
+       │                 ++
 
 ```
 
@@ -244,21 +246,21 @@ invalid.js:28:13 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:33:18 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     31 │ {
     32 │ 	let a, b;
   > 33 │ 	const c = a && (b = 0) ? 1 : 0;
        │ 	                ^^^^^
     34 │ }
-    35 │ 
-  
+    35 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     33 │ → const·c·=·a·&&·(b·===·0)·?·1·:·0;
-       │                      ++            
+       │                      ++
 
 ```
 
@@ -266,20 +268,20 @@ invalid.js:33:18 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:37:10 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     36 │ function f(a) {
   > 37 │ 	return (a = 5 + 1);
        │ 	        ^^^^^^^^^
     38 │ }
-    39 │ 
-  
+    39 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     37 │ → return·(a·===·5·+·1);
-       │              ++        
+       │              ++
 
 ```
 
@@ -287,21 +289,21 @@ invalid.js:37:10 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:40:5 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     38 │ }
-    39 │ 
+    39 │
   > 40 │ if (a = 0) {
        │     ^^^^^
     41 │ }
-    42 │ 
-  
+    42 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     40 │ if·(a·===·0)·{
-       │        ++     
+       │        ++
 
 ```
 
@@ -309,21 +311,21 @@ invalid.js:40:5 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:43:11 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     41 │ }
-    42 │ 
+    42 │
   > 43 │ if (a || (a = b)) {
        │           ^^^^^
     44 │ }
-    45 │ 
-  
+    45 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     43 │ if·(a·||·(a·===·b))·{
-       │              ++      
+       │              ++
 
 ```
 
@@ -331,17 +333,17 @@ invalid.js:43:11 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:46:5 lint/suspicious/noAssignInExpressions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     44 │ }
-    45 │ 
+    45 │
   > 46 │ if (a += b) {
        │     ^^^^^^
     47 │ }
-    48 │ 
-  
+    48 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
 
 ```
 
@@ -349,21 +351,21 @@ invalid.js:46:5 lint/suspicious/noAssignInExpressions ━━━━━━━━
 invalid.js:49:9 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     47 │ }
-    48 │ 
+    48 │
   > 49 │ while ((a = 0)) {}
        │         ^^^^^
-    50 │ 
+    50 │
     51 │ while (a *= b) {}
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     49 │ while·((a·===·0))·{}
-       │            ++       
+       │            ++
 
 ```
 
@@ -371,17 +373,17 @@ invalid.js:49:9 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:51:8 lint/suspicious/noAssignInExpressions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     49 │ while ((a = 0)) {}
-    50 │ 
+    50 │
   > 51 │ while (a *= b) {}
        │        ^^^^^^
-    52 │ 
+    52 │
     53 │ do {} while ((a = a + 1));
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
 
 ```
 
@@ -389,21 +391,21 @@ invalid.js:51:8 lint/suspicious/noAssignInExpressions ━━━━━━━━
 invalid.js:53:15 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     51 │ while (a *= b) {}
-    52 │ 
+    52 │
   > 53 │ do {} while ((a = a + 1));
        │               ^^^^^^^^^
-    54 │ 
+    54 │
     55 │ do {} while (((a -= 1), a));
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     53 │ do·{}·while·((a·===·a·+·1));
-       │                  ++         
+       │                  ++
 
 ```
 
@@ -411,17 +413,17 @@ invalid.js:53:15 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:55:16 lint/suspicious/noAssignInExpressions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     53 │ do {} while ((a = a + 1));
-    54 │ 
+    54 │
   > 55 │ do {} while (((a -= 1), a));
        │                ^^^^^^
-    56 │ 
+    56 │
     57 │ do {} while (((a = a + 1), a));
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
 
 ```
 
@@ -429,21 +431,21 @@ invalid.js:55:16 lint/suspicious/noAssignInExpressions ━━━━━━━━
 invalid.js:57:16 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     55 │ do {} while (((a -= 1), a));
-    56 │ 
+    56 │
   > 57 │ do {} while (((a = a + 1), a));
        │                ^^^^^^^^^
-    58 │ 
+    58 │
     59 │ do {} while (a || (a = b));
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     57 │ do·{}·while·(((a·===·a·+·1),·a));
-       │                   ++             
+       │                   ++
 
 ```
 
@@ -451,21 +453,21 @@ invalid.js:57:16 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:59:20 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     57 │ do {} while (((a = a + 1), a));
-    58 │ 
+    58 │
   > 59 │ do {} while (a || (a = b));
        │                    ^^^^^
-    60 │ 
+    60 │
     61 │ for (let a = 5; (a = 0); i--) {}
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     59 │ do·{}·while·(a·||·(a·===·b));
-       │                       ++     
+       │                       ++
 
 ```
 
@@ -473,21 +475,21 @@ invalid.js:59:20 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:61:18 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     59 │ do {} while (a || (a = b));
-    60 │ 
+    60 │
   > 61 │ for (let a = 5; (a = 0); i--) {}
        │                  ^^^^^
-    62 │ 
+    62 │
     63 │ for (let x = 0; (x += 1); ) {}
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     61 │ for·(let·a·=·5;·(a·===·0);·i--)·{}
-       │                     ++            
+       │                     ++
 
 ```
 
@@ -495,17 +497,17 @@ invalid.js:61:18 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:63:18 lint/suspicious/noAssignInExpressions ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     61 │ for (let a = 5; (a = 0); i--) {}
-    62 │ 
+    62 │
   > 63 │ for (let x = 0; (x += 1); ) {}
        │                  ^^^^^^
-    64 │ 
+    64 │
     65 │ for (let l; typeof l === "undefined" ? (l = 0) : l; i++) {}
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
 
 ```
 
@@ -513,21 +515,21 @@ invalid.js:63:18 lint/suspicious/noAssignInExpressions ━━━━━━━━
 invalid.js:65:41 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     63 │ for (let x = 0; (x += 1); ) {}
-    64 │ 
+    64 │
   > 65 │ for (let l; typeof l === "undefined" ? (l = 0) : l; i++) {}
        │                                         ^^^^^
-    66 │ 
+    66 │
     67 │ for (; (a = y); ) {}
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     65 │ for·(let·l;·typeof·l·===·"undefined"·?·(l·===·0)·:·l;·i++)·{}
-       │                                            ++                
+       │                                            ++
 
 ```
 
@@ -535,21 +537,21 @@ invalid.js:65:41 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:67:9 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     65 │ for (let l; typeof l === "undefined" ? (l = 0) : l; i++) {}
-    66 │ 
+    66 │
   > 67 │ for (; (a = y); ) {}
        │         ^^^^^
-    68 │ 
+    68 │
     69 │ for (let a = (b = 1); a < 5; ) {}
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     67 │ for·(;·(a·===·y);·)·{}
-       │            ++         
+       │            ++
 
 ```
 
@@ -557,21 +559,21 @@ invalid.js:67:9 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:69:15 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     67 │ for (; (a = y); ) {}
-    68 │ 
+    68 │
   > 69 │ for (let a = (b = 1); a < 5; ) {}
        │               ^^^^^
-    70 │ 
+    70 │
     71 │ switch (foo) {
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     69 │ for·(let·a·=·(b·===·1);·a·<·5;·)·{}
-       │                  ++                
+       │                  ++
 
 ```
 
@@ -579,20 +581,20 @@ invalid.js:69:15 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:72:8 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     71 │ switch (foo) {
   > 72 │ 	case (a = b):
        │ 	      ^^^^^
     73 │ 		bar();
     74 │ }
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     72 │ → case·(a·===·b):
-       │            ++    
+       │            ++
 
 ```
 
@@ -600,20 +602,20 @@ invalid.js:72:8 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:77:14 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     76 │ switch (foo) {
   > 77 │ 	case baz + (a = b):
        │ 	            ^^^^^
     78 │ 		bar();
     79 │ }
-  
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
+
     77 │ → case·baz·+·(a·===·b):
-       │                  ++    
+       │                  ++
 
 ```
 
@@ -621,20 +623,42 @@ invalid.js:77:14 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
 invalid.js:81:2 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
   ! The assignment should not be in an expression.
-  
+
     79 │ }
-    80 │ 
-  > 81 │ ((3496.29).bkufyydt = 2e308) ? foo : bar;
-       │  ^^^^^^^^^^^^^^^^^^^^^^^^^^
-    82 │ 
-  
+    80 │
+  > 81 │ ((3496.29/*1*/)/*2*/.bkufyydt/*3*/ = /*4*/2e308/*5*/)/*6*/ ? foo : bar;
+       │  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    82 │
+    83 │ res.onAborted(() => /*0*/(/*1*/(/*2*/a/*3*/./*4*/b/*5*/)/*6*/ /*7*/ = /*8*/ /*9*/true/*10*/));
+
+  i The use of assignments in expressions is confusing.
+    Expressions are often considered as side-effect free.
+
+  i Suggested fix: Did you mean '==='?
+
+    81 │ ((3496.29/*1*/)/*2*/.bkufyydt/*3*/·===·/*4*/2e308/*5*/)/*6*/·?·foo·:·bar;
+       │                                     ++
+
+```
+
+```
+invalid.js:83:32 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The assignment should not be in an expression.
+
+    81 │ ((3496.29/*1*/)/*2*/.bkufyydt/*3*/ = /*4*/2e308/*5*/)/*6*/ ? foo : bar;
+    82 │
+  > 83 │ res.onAborted(() => /*0*/(/*1*/(/*2*/a/*3*/./*4*/b/*5*/)/*6*/ /*7*/ = /*8*/ /*9*/true/*10*/));
+       │                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    84 │
+
   i The use of assignments in expressions is confusing.
     Expressions are often considered as side-effect free.
-  
+
   i Suggested fix: Did you mean '==='?
-  
-    81 │ ((3496.29).bkufyydt·===·2e308)·?·foo·:·bar;
-       │                      ++                    
+
+    83 │ res.onAborted(()·=>·/*0*/(/*1*/(/*2*/a/*3*/./*4*/b/*5*/)/*6*/·/*7*/·===·/*8*/·/*9*/true/*10*/));
+       │                                                                      ++
 
 ```