Add flip binary operands code action by corvid-agent · Pull Request #2531 · swiftlang/sourcekit-lsp

corvid-agent · 2026-03-02T20:13:19Z

Adds a new FlipBinaryOperands syntactic code action that swaps the left and right operands of a binary expression, adjusting the operator when needed.

Behavior

Commutative operators (+, *, ==, !=, &&, ||, etc.) — operands are simply swapped:

let sum = 1 + value  →  let sum = value + 1

Comparison operators — the operator is also flipped to preserve semantics:

Before	After
`5 < count`	`count > 5`
`a > b`	`b < a`
`a <= b`	`b >= a`
`a >= b`	`b <= a`

Changes

FlipBinaryOperands.swift — new code action provider
SyntaxCodeActions.swift — register the provider
CMakeLists.txt — add the new file
CodeActionTests.swift — 7 tests covering commutative, comparison, and equality operators

Test plan

swift build --target SwiftLanguageService passes
CI tests pass
@0xLeif review

Adds a new syntactic code action that swaps the left and right operands of a binary expression. For comparison operators (<, >, <=, >=), the operator is also flipped to preserve semantics. Commutative operators are swapped without modification. Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

ahoppen

Thanks for your contribution @corvid-agent. I have a few comments inline but the overall implementation looks solid.

ahoppen · 2026-03-08T10:17:24Z

+      .with(\.trailingTrivia, rightOperand.trailingTrivia)
+
+    let newOperator: ExprSyntax
+    if flippedOperator != operatorText {


Is this check actually needed? If flippedOperator == operatorText then overwriting the operator doesn’t do any harm.

Good point — removed the guard. The new operator token is always constructed now, even when the text is the same.

ahoppen · 2026-03-08T10:17:45Z

+    let newOperator: ExprSyntax
+    if flippedOperator != operatorText {
+      newOperator = ExprSyntax(
+        binaryOp.with(\.operator, .binaryOperator(flippedOperator))


Do we need to preserve trivia of the original operator here?

Fixed — the flipped operator token now preserves both leading and trailing trivia from the original.

ahoppen · 2026-03-08T10:20:56Z

+/// ```swift
+/// if 5 < count { }  →  if count > 5 { }
+/// ```
+struct FlipBinaryOperands: SyntaxCodeActionProvider {


Could we implement this as an SyntaxRefactoringCodeActionProvider similar to AddDocumentation? That gives us some convenience functionality to construct the CodeAction and would allow us to move this to swift-syntax if we want to in the future.

Done — refactored to match the AddDocumentation pattern: EditRefactoringProvider with textRefactor + SyntaxRefactoringCodeActionProvider extension with nodeToRefactor and title.

ahoppen · 2026-03-08T10:23:10Z

+    case ">": return "<"
+    case "<=": return ">="
+    case ">=": return "<="
+    default: return op


We shouldn’t assume that all operators not listed above are commutative. Users may, for example, have their own non-commutative operators. And eg. + on strings or - is not commutative. Instead, we should have an allow-list of commutative operators.

Great catch — replaced the blocklist with an explicit allowlist: ==, \!=, &&, ||, &, |, ^, <, >, <=, >=. Comparison operators still get flipped (e.g. < → >).

ahoppen · 2026-03-08T10:23:33Z

+  /// Walk up the tree to find the nearest `InfixOperatorExprSyntax` that
+  /// contains the current node.
+  func findEnclosingInfixOperator() -> InfixOperatorExprSyntax? {
+    var current: Syntax? = Syntax(self)


You should be able to user ancestorOrSelf here.

Switched to findParentOfSelf(ofType:stoppingIf:) — same pattern AddDocumentation uses for its ancestor walk.

ahoppen · 2026-03-08T10:25:14Z

+      """
+      let sum = 1️⃣1 + value2️⃣
+      """,
+      ranges: [("1️⃣", "2️⃣")],


Do we need to specify the ranges here? Doesn’t the default invoke the code actions on all markers and w should return the actions on all markers?

You're right — removed the explicit ranges: from all tests. The default behavior covers all markers.

- Refactor to use SyntaxRefactoringCodeActionProvider pattern with EditRefactoringProvider, separating node finding (nodeToRefactor) from refactoring logic (textRefactor) - Replace non-commutative blocklist with commutative operator allowlist (==, !=, &&, ||, &, |, ^, <, >, <=, >=) to avoid flipping user-defined or non-commutative operators like + on strings - Remove unnecessary flippedOperator == operatorText guard; always construct the new operator token - Preserve trivia of the original operator when constructing the flipped operator token - Use findParentOfSelf instead of manual ancestor walking - Remove unnecessary range specifications in tests; default invocation checks all markers Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

corvid-agent · 2026-03-09T13:23:42Z

Thanks for the thorough review @ahoppen! All 6 items addressed in the latest push:

Refactored to EditRefactoringProvider + SyntaxRefactoringCodeActionProvider (matching AddDocumentation pattern)
Replaced operator blocklist with explicit allowlist (==, \!=, &&, ||, &, |, ^, <, >, <=, >=)
Removed the unnecessary flippedOperator == operatorText guard
Operator token now preserves original trivia
Using findParentOfSelf(ofType:stoppingIf:) for ancestor walk
Removed explicit ranges: from all tests

rintaro · 2026-03-10T17:40:51Z

We decided not to accept this code action #2520 (comment)

rintaro · 2026-03-11T04:21:24Z

Reopened #2520

PhantomInTheWire · 2026-03-17T21:01:32Z

@rintaro @ahoppen out of curiosity what is the policy on non human contributors since it seems @corvid-agent is an ai agent per their profile

rintaro · 2026-03-30T22:52:04Z

We recently established an official policy on AI-assisted contributions: https://github.com/swiftlang/project-operations/blob/main/contributing/ai-tools.md

@corvid-agent, since you describe yourself as an “AI software engineer,” I’m going to close this PR for now. If you are in fact a human contributor and are able to comply with the policy, please feel free to reopen it.

corvid-agent requested review from ahoppen, hamishknight and rintaro as code owners March 2, 2026 20:13

rintaro mentioned this pull request Mar 7, 2026

Add 'Flip operands of binary expression' code action #2538

Closed

ahoppen reviewed Mar 8, 2026

View reviewed changes

rintaro closed this Mar 10, 2026

rintaro reopened this Mar 11, 2026

rintaro closed this Mar 30, 2026

Conversation

corvid-agent commented Mar 2, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Behavior

Changes

Test plan

Uh oh!

ahoppen left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

corvid-agent commented Mar 9, 2026

Uh oh!

rintaro commented Mar 10, 2026

Uh oh!

rintaro commented Mar 11, 2026

Uh oh!

PhantomInTheWire commented Mar 17, 2026

Uh oh!

rintaro commented Mar 30, 2026

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

4 participants

corvid-agent commented Mar 2, 2026 •

edited

Loading