Rename compositeName to multipleNames. Simplify LookupName.debugDescription string concatenation for multipleNames case.

Author: MAJKFL

Sources/SwiftLexicalLookup/LookupName.swift

@@ -139,7 +139,7 @@ import SwiftSyntax
   case implicit(ImplicitDecl)
   /// Dollar identifier introduced by a closure without parameters.
   case dollarIdentifier(ClosureExprSyntax, strRepresentation: String)
-  /// Represents equivalent identifiers grouped together.
+  /// Represents equivalent names grouped together.
   /// - Important: The array should be non-empty.
   ///
   /// ### Example:
@@ -150,8 +150,8 @@ import SwiftSyntax
   /// }
   /// ```
   /// For lookup at the given position, the result
-  /// contains only one (composite) name
-  case compositeName([LookupName])
+  /// contains only one name, that represents both `let x` declarations.
+  case equivalentNames([LookupName])
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
@@ -164,7 +164,7 @@ import SwiftSyntax
       return implicitName.syntax
     case .dollarIdentifier(let closureExpr, _):
       return closureExpr
-    case .compositeName(let names):
+    case .equivalentNames(let names):
       return names.first!.syntax
     }
   }
@@ -180,7 +180,7 @@ import SwiftSyntax
       return kind.identifier
     case .dollarIdentifier(_, strRepresentation: _):
       return nil
-    case .compositeName(let names):
+    case .equivalentNames(let names):
       return names.first!.identifier
     }
   }
@@ -202,7 +202,7 @@ import SwiftSyntax
       return implicitName.position
     case .dollarIdentifier(let closureExpr, _):
       return closureExpr.positionAfterSkippingLeadingTrivia
-    case .compositeName(let names):
+    case .equivalentNames(let names):
       return names.first!.position
     }
   }
@@ -338,20 +338,8 @@ 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
+    case .equivalentNames(let names):
+      return "Composite name: [ \(names.map(\.debugDescription).joined(separator: ", ")) ]"
     }
   }
 }

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -598,19 +598,15 @@ import SwiftSyntax
         orderedKeys.append(identifier)
       }
 
-      if partitioned[identifier] == nil {
-        partitioned[identifier] = [extractedName]
-      } else {
-        partitioned[identifier]?.append(extractedName)
-      }
+      partitioned[identifier, default: []].append(extractedName)
     }
 
     return
       orderedKeys
       .compactMap { key in
         guard let names = partitioned[key] else { return nil }
 
-        return .compositeName(names)
+        return .equivalentNames(names)
       }
   }
 

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -106,7 +106,7 @@ func assertLexicalNameLookup(
 
       return result.flatMap { lookUpResult in
         lookUpResult.names.flatMap { lookupName in
-          if case .compositeName(let names) = lookupName {
+          if case .equivalentNames(let names) = lookupName {
             return names.map(\.syntax)
           } else {
             return [lookupName.syntax]

Tests/SwiftLexicalLookupTest/ExpectedName.swift

@@ -93,7 +93,7 @@ enum NameExpectation: ExpectedName {
         actualStr == expectedStr,
         "For marker \(marker), actual identifier \(actualStr) doesn't match expected \(expectedStr)"
       )
-    case (.compositeName(let actualNames), .compositeName(let expectedNames)):
+    case (.equivalentNames(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)"