Add composite name handling in switch cases.

Author: MAJKFL

Sources/SwiftLexicalLookup/LookupName.swift

@@ -139,6 +139,19 @@ import SwiftSyntax
   case implicit(ImplicitDecl)
   /// Dollar identifier introduced by a closure without parameters.
   case dollarIdentifier(ClosureExprSyntax, strRepresentation: String)
+  /// Equivalent identifiers grouped together.
+  /// The associated array of names is always non-empty.
+  ///
+  /// ### Example:
+  /// ```swift
+  /// switch x {
+  /// case .a(let smth), .b(let smth):
+  ///   print(smth) // <-- lookup here
+  /// }
+  /// ```
+  /// For lookup at the given position, the result
+  /// contains only one (composite) name
+  case compositeName([LookupName])
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
@@ -151,6 +164,8 @@ import SwiftSyntax
       return implicitName.syntax
     case .dollarIdentifier(let closureExpr, _):
       return closureExpr
+    case .compositeName(let names):
+      return names.first!.syntax
     }
   }
 
@@ -165,6 +180,8 @@ import SwiftSyntax
       return kind.identifier
     case .dollarIdentifier(_, strRepresentation: _):
       return nil
+    case .compositeName(let names):
+      return names.first!.identifier
     }
   }
 
@@ -185,6 +202,8 @@ import SwiftSyntax
       return implicitName.position
     case .dollarIdentifier(let closureExpr, _):
       return closureExpr.positionAfterSkippingLeadingTrivia
+    case .compositeName(let names):
+      return names.first!.position
     }
   }
 
@@ -319,6 +338,20 @@ import SwiftSyntax
       return "implicit: \(strName)"
     case .dollarIdentifier(_, strRepresentation: let str):
       return "dollarIdentifier: \(str)"
+    case .compositeName(let names):
+      var result = "Composite name: [ "
+
+      for (index, name) in names.enumerated() {
+        result += name.debugDescription
+
+        if index < names.count - 1 {
+          result += ", "
+        } else {
+          result += " ]"
+        }
+      }
+
+      return result
     }
   }
 }

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -574,13 +574,44 @@ import SwiftSyntax
 @_spi(Experimental) extension SwitchCaseSyntax: SequentialScopeSyntax {
   /// Names introduced within `case` items.
   var namesFromLabel: [LookupName] {
-    label.as(SwitchCaseLabelSyntax.self)?.caseItems.flatMap { child in
+    guard let switchCaseItemList = label.as(SwitchCaseLabelSyntax.self)?.caseItems else { return [] }
+
+    let extractedNames = switchCaseItemList.flatMap { child in
       if let exprPattern = child.pattern.as(ExpressionPatternSyntax.self) {
         return LookupName.getNames(from: exprPattern.expression)
       } else {
         return LookupName.getNames(from: child.pattern)
       }
-    } ?? []
+    }
+
+    if switchCaseItemList.count <= 1 {
+      return extractedNames
+    }
+
+    var orderedKeys: [Identifier] = []
+    var partitioned: [Identifier: [LookupName]] = [:]
+
+    for extractedName in extractedNames {
+      guard let identifier = extractedName.identifier else { continue }
+
+      if !partitioned.keys.contains(identifier) {
+        orderedKeys.append(identifier)
+      }
+
+      if partitioned[identifier] == nil {
+        partitioned[identifier] = [extractedName]
+      } else {
+        partitioned[identifier]?.append(extractedName)
+      }
+    }
+
+    return
+      orderedKeys
+      .compactMap { key in
+        guard let names = partitioned[key] else { return nil }
+
+        return .compositeName(names)
+      }
   }
 
   /// Names introduced within `case` items

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -105,14 +105,18 @@ func assertLexicalNameLookup(
       ResultExpectation.assertResult(marker: marker, result: result, expectedValues: expectedValues)
 
       return result.flatMap { lookUpResult in
-        lookUpResult.names.map { lookupName in
-          lookupName.syntax
+        lookUpResult.names.flatMap { lookupName in
+          if case .compositeName(let names) = lookupName {
+            return names.map(\.syntax)
+          } else {
+            return [lookupName.syntax]
+          }
         }
       }
     },
     expected: references.mapValues { expectations in
       expectations.flatMap { expectation in
-        expectation.expectedNames.map { expectedName in
+        expectation.expectedNames.flatMap { expectedName in
           expectedName.marker
         }
       }

Tests/SwiftLexicalLookupTest/ExpectedName.swift

@@ -16,12 +16,12 @@ import XCTest
 
 /// Used to define lookup name assertion.
 protocol ExpectedName {
-  var marker: String { get }
+  var marker: [String] { get }
 }
 
 extension String: ExpectedName {
-  var marker: String {
-    self
+  var marker: [String] {
+    [self]
   }
 }
 
@@ -63,15 +63,22 @@ enum NameExpectation: ExpectedName {
   case declaration(String)
   case implicit(ImplicitNameExpectation)
   case dollarIdentifier(String, String)
+  case compositeName([NameExpectation])
 
-  var marker: String {
+  var marker: [String] {
     switch self {
     case .identifier(let marker),
       .declaration(let marker),
       .dollarIdentifier(let marker, _):
-      return marker
+      return [marker]
     case .implicit(let implicitName):
-      return implicitName.marker
+      return [implicitName.marker]
+    case .compositeName(let expectedNames):
+      return
+        expectedNames
+        .flatMap { expectedName in
+          expectedName.marker
+        }
     }
   }
 
@@ -86,6 +93,15 @@ enum NameExpectation: ExpectedName {
         actualStr == expectedStr,
         "For marker \(marker), actual identifier \(actualStr) doesn't match expected \(expectedStr)"
       )
+    case (.compositeName(let actualNames), .compositeName(let expectedNames)):
+      XCTAssert(
+        actualNames.count == expectedNames.count,
+        "For marker \(marker), actual composite name count \(actualNames.count) doesn't match expected \(expectedNames.count)"
+      )
+
+      for (actualName, expectedName) in zip(actualNames, expectedNames) {
+        expectedName.assertExpectation(marker: marker, for: actualName)
+      }
     default:
       XCTFail("For marker \(marker), actual name kind \(name) doesn't match expected \(self)")
     }

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -791,9 +791,11 @@ final class testNameLookup: XCTestCase {
     assertLexicalNameLookup(
       source: """
         switch {
-        case .x(let 1️⃣a, let 2️⃣b), .y(.c(let 3️⃣c), .z):
-          print(4️⃣a, 5️⃣b, 6️⃣c)
-        case .z(let 7️⃣a), .smth(let 8️⃣a)
+        case .x(let 1️⃣a, let 2️⃣b):
+          print(4️⃣a, 5️⃣b)
+        case .y(.c(let 3️⃣c), .z):
+          print(6️⃣c)
+        case .z(let 7️⃣a)
           print(9️⃣a)
         default:
           print(0️⃣a)
@@ -803,13 +805,45 @@ final class testNameLookup: XCTestCase {
         "4️⃣": [.fromScope(SwitchCaseSyntax.self, expectedNames: ["1️⃣"])],
         "5️⃣": [.fromScope(SwitchCaseSyntax.self, expectedNames: ["2️⃣"])],
         "6️⃣": [.fromScope(SwitchCaseSyntax.self, expectedNames: ["3️⃣"])],
-        "9️⃣": [.fromScope(SwitchCaseSyntax.self, expectedNames: ["7️⃣", "8️⃣"])],
+        "9️⃣": [.fromScope(SwitchCaseSyntax.self, expectedNames: ["7️⃣"])],
         "0️⃣": [],
       ],
       expectedResultTypes: .all(IdentifierPatternSyntax.self)
     )
   }
 
+  func testCompositeNames() {
+    assertLexicalNameLookup(
+      source: """
+        switch X {
+        case .x(let 1️⃣a, let 2️⃣b), .y(let 3️⃣a, let 4️⃣b):
+          print(5️⃣x)
+        case .z(let 7️⃣a), .smth(let 8️⃣a):
+          print(9️⃣x)
+        }
+        """,
+      references: [
+        "5️⃣": [
+          .fromScope(
+            SwitchCaseSyntax.self,
+            expectedNames: [
+              NameExpectation.compositeName([.identifier("1️⃣"), .identifier("3️⃣")]),
+              NameExpectation.compositeName([.identifier("2️⃣"), .identifier("4️⃣")]),
+            ]
+          )
+        ],
+        "9️⃣": [
+          .fromScope(
+            SwitchCaseSyntax.self,
+            expectedNames: [NameExpectation.compositeName([.identifier("7️⃣"), .identifier("8️⃣")])]
+          )
+        ],
+      ],
+      expectedResultTypes: .all(IdentifierPatternSyntax.self),
+      useNilAsTheParameter: true
+    )
+  }
+
   func testSimpleGenericParameterScope() {
     assertLexicalNameLookup(
       source: """