fix(linter/prefer-at): wrap expressions in parentheses when needed for member access (#16643)

Author: camc314

crates/oxc_linter/src/rules/eslint/no_extra_boolean_cast.rs

@@ -1,13 +1,13 @@
 use oxc_ast::{
     AstKind,
-    ast::{CallExpression, Expression, NewExpression, match_member_expression},
+    ast::{CallExpression, Expression, NewExpression},
 };
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
 use oxc_syntax::{
     operator::{LogicalOperator, UnaryOperator},
-    precedence::{GetPrecedence, Precedence},
+    precedence::Precedence,
 };
 use schemars::JsonSchema;
 use serde::Deserialize;
@@ -16,6 +16,7 @@ use crate::{
     AstNode,
     context::LintContext,
     rule::{DefaultRuleConfig, Rule},
+    utils::get_precedence,
 };
 
 fn no_extra_double_negation_cast_diagnostic(span: Span) -> OxcDiagnostic {
@@ -246,28 +247,6 @@ fn without_not<'a, 'b>(expr: &'b Expression<'a>) -> Option<&'b Expression<'a>> {
     }
 }
 
-/// Returns the precedence of an expression if it has one.
-/// Returns `None` for "atomic" expressions (literals, identifiers, etc.) that have
-/// the highest precedence and never need parentheses.
-fn get_precedence(expr: &Expression) -> Option<Precedence> {
-    match expr {
-        Expression::SequenceExpression(e) => Some(e.precedence()),
-        Expression::AssignmentExpression(e) => Some(e.precedence()),
-        Expression::YieldExpression(e) => Some(e.precedence()),
-        Expression::ConditionalExpression(e) => Some(e.precedence()),
-        Expression::LogicalExpression(e) => Some(e.precedence()),
-        Expression::BinaryExpression(e) => Some(e.precedence()),
-        Expression::UnaryExpression(e) => Some(e.precedence()),
-        Expression::UpdateExpression(e) => Some(e.precedence()),
-        Expression::AwaitExpression(e) => Some(e.precedence()),
-        Expression::NewExpression(e) => Some(e.precedence()),
-        Expression::CallExpression(e) => Some(e.precedence()),
-        match_member_expression!(Expression) => Some(expr.to_member_expression().precedence()),
-        // Literals, identifiers, and other atomic expressions have highest precedence
-        _ => None,
-    }
-}
-
 #[test]
 fn test() {
     use crate::tester::Tester;

crates/oxc_linter/src/rules/unicorn/prefer_at.rs

@@ -1,3 +1,8 @@
+use oxc_syntax::precedence::Precedence;
+use schemars::JsonSchema;
+use serde::Deserialize;
+use serde_json::Value;
+
 use oxc_ast::{
     AstKind,
     ast::{
@@ -9,16 +14,13 @@ use oxc_ast::{
 use oxc_diagnostics::OxcDiagnostic;
 use oxc_macros::declare_oxc_lint;
 use oxc_span::{GetSpan, Span};
-use schemars::JsonSchema;
-use serde::Deserialize;
-use serde_json::Value;
 
 use crate::{
     AstNode,
     context::LintContext,
     fixer::{RuleFix, RuleFixer},
     rule::Rule,
-    utils::is_same_expression,
+    utils::{get_precedence, is_same_expression},
 };
 
 fn prefer_at_diagnostic(span: Span, method: &str) -> OxcDiagnostic {
@@ -579,7 +581,14 @@ fn check_lodash_last<'a>(
             ctx.diagnostic_with_fix(
                 prefer_at_diagnostic(call_expr.span, &format!("{name}.last()")),
                 |fixer| {
-                    let new_code = format!("{}.at(-1)", fixer.source_range(arg.span()));
+                    let arg_text = fixer.source_range(arg.span());
+                    let new_code = if get_precedence(arg)
+                        .is_some_and(|precedence| precedence < Precedence::Member)
+                    {
+                        format!("({arg_text}).at(-1)")
+                    } else {
+                        format!("{arg_text}.at(-1)")
+                    };
                     fixer.replace(call_expr.span, new_code)
                 },
             );
@@ -756,6 +765,8 @@ fn test() {
         ("lodash.last(array)", "array.at(-1)", None),
         // Edge cases with very large numbers
         ("array[array.length - 9007199254740992]", "array.at(-9007199254740992)", None),
+        ("_.last([] as [])", "([] as []).at(-1)", None),
+        ("_.last([1, 2, 3] as const)", "([1, 2, 3] as const).at(-1)", None),
     ];
 
     Tester::new(PreferAt::NAME, PreferAt::PLUGIN, pass, fail).expect_fix(fix).test_and_snapshot();

crates/oxc_linter/src/utils/unicorn.rs

@@ -2,12 +2,15 @@ use oxc_ast::{
     AstKind,
     ast::{
         BindingPatternKind, CallExpression, Expression, FormalParameters, FunctionBody,
-        LogicalExpression, MemberExpression, Statement,
+        LogicalExpression, MemberExpression, Statement, match_member_expression,
     },
 };
 use oxc_semantic::AstNode;
 use oxc_span::{ContentEq, Span};
-use oxc_syntax::operator::LogicalOperator;
+use oxc_syntax::{
+    operator::LogicalOperator,
+    precedence::{GetPrecedence, Precedence},
+};
 
 use crate::LintContext;
 
@@ -375,3 +378,34 @@ where
 
     false
 }
+
+/// Returns the precedence of an expression if it has one.
+///
+/// Returns `None` for "atomic" expressions (literals, identifiers, etc.) that have
+/// the highest precedence and never need parentheses when used as operands.
+///
+/// This is useful for determining if parentheses are needed when transforming code.
+/// If `get_precedence(expr)` returns `None`, the expression never needs parentheses.
+/// If it returns `Some(p)`, compare `p` against the context's precedence to decide.
+pub fn get_precedence(expr: &Expression) -> Option<Precedence> {
+    match expr {
+        Expression::SequenceExpression(e) => Some(e.precedence()),
+        Expression::AssignmentExpression(e) => Some(e.precedence()),
+        Expression::YieldExpression(e) => Some(e.precedence()),
+        Expression::ConditionalExpression(e) => Some(e.precedence()),
+        Expression::LogicalExpression(e) => Some(e.precedence()),
+        Expression::BinaryExpression(e) => Some(e.precedence()),
+        Expression::UnaryExpression(e) => Some(e.precedence()),
+        Expression::UpdateExpression(e) => Some(e.precedence()),
+        Expression::AwaitExpression(e) => Some(e.precedence()),
+        Expression::NewExpression(e) => Some(e.precedence()),
+        Expression::CallExpression(e) => Some(e.precedence()),
+        match_member_expression!(Expression) => Some(expr.to_member_expression().precedence()),
+        Expression::TSAsExpression(_)
+        | Expression::TSSatisfiesExpression(_)
+        | Expression::TSTypeAssertion(_)
+        | Expression::ArrowFunctionExpression(_) => Some(Precedence::Lowest),
+        // Literals, identifiers, and other atomic expressions have highest precedence
+        _ => None,
+    }
+}