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..7acedc8c73c 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, AstSeparatedList, 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,351 @@ 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();
+        let mut separators = Vec::new();
+
+        for element in value.elements().elements() {
+            if let Ok(Some(separator)) = element.trailing_separator {
+                separators.push(separator);
+            }
+
+            let element = match element.node? {
+                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(), separators.into_iter());
+
+        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();
+        let mut separators = Vec::new();
+
+        for property in properties.elements() {
+            if let Ok(Some(separator)) = property.trailing_separator {
+                separators.push(separator);
+            }
+
+            let member = match property.node? {
+                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(), separators.into_iter());
+
+        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..203ac59eb5e 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,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*/));
+
+
+(/*1*/[/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/]/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
+(/*1*/{/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/}/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
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..19bc036a8e7 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,13 @@ 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*/));
+
+
+(/*1*/[/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/]/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
+(/*1*/{/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/}/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
 
 ```
 
@@ -624,17 +629,79 @@ invalid.js:81:2 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━
   
     79 │ }
     80 │ 
-  > 81 │ ((3496.29).bkufyydt = 2e308) ? foo : bar;
-       │  ^^^^^^^^^^^^^^^^^^^^^^^^^^
+  > 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 '==='?
+  
+    83 │ res.onAborted(()·=>·/*0*/(/*1*/(/*2*/a/*3*/./*4*/b/*5*/)/*6*/·/*7*/·===·/*8*/·/*9*/true/*10*/));
+       │                                                                      ++                         
+
+```
+
+```
+invalid.js:86:7 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The assignment should not be in an expression.
+  
+  > 86 │ (/*1*/[/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/]/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
+       │       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    87 │ (/*1*/{/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/}/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
+    88 │ 
+  
+  i The use of assignments in expressions is confusing.
+    Expressions are often considered as side-effect free.
+  
+  i Suggested fix: Did you mean '==='?
+  
+    86 │ (/*1*/[/*2*/a/*3*/,/*4*/b/*5*/,·/*6*/c/*7*/]/*8*//*9*/===/*10*/·2e308)·?·foo·:·bar;
+       │                                                        ++                          
+
+```
+
+```
+invalid.js:87:7 lint/suspicious/noAssignInExpressions  FIXABLE  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  ! The assignment should not be in an expression.
+  
+    86 │ (/*1*/[/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/]/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
+  > 87 │ (/*1*/{/*2*/a/*3*/,/*4*/b/*5*/, /*6*/c/*7*/}/*8*//*9*/=/*10*/ 2e308) ? foo : bar;
+       │       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+    88 │ 
   
   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;
-       │                      ++                    
+    87 │ (/*1*/{/*2*/a/*3*/,/*4*/b/*5*/,·/*6*/c/*7*/}/*8*//*9*/===/*10*/·2e308)·?·foo·:·bar;
+       │                                                        ++                          
 
 ```