Create a new enum representing all possible implicit name cases. Simplify LookupName.

Author: MAJKFL

Sources/SwiftLexicalLookup/LookupName.swift

@@ -12,39 +12,25 @@
 
 import SwiftSyntax
 
-@_spi(Experimental) public enum LookupName {
-  /// Identifier associated with the name.
-  /// Could be an identifier of a variable, function or closure parameter and more
-  case identifier(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
-  /// Declaration associated with the name.
-  /// Could be class, struct, actor, protocol, function and more
-  case declaration(NamedDeclSyntax, accessibleAfter: AbsolutePosition?)
+@_spi(Experimental) public enum LookupImplicitNameKind {
   /// `self` keyword representing object instance.
-  case `self`(DeclSyntaxProtocol)
+  case `self`(SyntaxProtocol)
   /// `Self` keyword representing object type.
   case `Self`(DeclSyntaxProtocol)
   /// `self` captured by a closure.
-  case selfCaptured(ClosureCaptureSyntax)
-  /// `error` available inside `catch` clause.
   case error(CatchClauseSyntax)
   /// `newValue` available by default inside `set` and `willSet`.
   case newValue(AccessorDeclSyntax)
   /// `oldValue` available by default inside `didSet`.
   case oldValue(AccessorDeclSyntax)
-
+  
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
     switch self {
-    case .identifier(let syntax, _):
-      syntax
-    case .declaration(let syntax, _):
-      syntax
     case .self(let syntax):
       syntax
     case .Self(let syntax):
       syntax
-    case .selfCaptured(let syntax):
-      syntax
     case .error(let syntax):
       syntax
     case .newValue(let syntax):
@@ -53,6 +39,45 @@ import SwiftSyntax
       syntax
     }
   }
+  
+  /// Used for name comparison.
+  var name: String {
+    switch self {
+    case .self:
+      "self"
+    case .Self:
+      "Self"
+    case .error:
+      "error"
+    case .newValue:
+      "newValue"
+    case .oldValue:
+      "oldValue"
+    }
+  }
+}
+
+@_spi(Experimental) public enum LookupName {
+  /// Identifier associated with the name.
+  /// Could be an identifier of a variable, function or closure parameter and more.
+  case identifier(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
+  /// Declaration associated with the name.
+  /// Could be class, struct, actor, protocol, function and more.
+  case declaration(NamedDeclSyntax, accessibleAfter: AbsolutePosition?)
+  /// Name introduced implicitly certain syntax nodes.
+  case implicit(LookupImplicitNameKind)
+
+  /// Syntax associated with this name.
+  @_spi(Experimental) public var syntax: SyntaxProtocol {
+    switch self {
+    case .identifier(let syntax, _):
+      syntax
+    case .declaration(let syntax, _):
+      syntax
+    case .implicit(let implicitName):
+      implicitName.syntax
+    }
+  }
 
   /// Introduced name.
   @_spi(Experimental) public var identifier: Identifier? {
@@ -82,16 +107,8 @@ import SwiftSyntax
     switch self {
     case .identifier, .declaration:
       identifier?.name
-    case .self, .selfCaptured:
-      "self"
-    case .Self:
-      "Self"
-    case .error:
-      "error"
-    case .newValue:
-      "newValue"
-    case .oldValue:
-      "oldValue"
+    case .implicit(let implicitName):
+      implicitName.name
     }
   }
 
@@ -153,7 +170,7 @@ import SwiftSyntax
     if let closureCapture = identifiable as? ClosureCaptureSyntax,
       closureCapture.identifier.tokenKind == .keyword(.self)
     {
-      return [.selfCaptured(closureCapture)]  // Handle `self` closure capture.
+      return [.implicit(.self(closureCapture))]  // Handle `self` closure capture.
     } else if identifiable.identifier.text != "_" {
       return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     } else {

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -379,9 +379,9 @@ extension SyntaxProtocol {
     } else {
       switch accessorSpecifier.tokenKind {
       case .keyword(.set), .keyword(.willSet):
-        [.newValue(self)]
+        [.implicit(.newValue(self))]
       case .keyword(.didSet):
-        [.oldValue(self)]
+        [.implicit(.oldValue(self))]
       default:
         []
       }

Sources/SwiftLexicalLookup/TypeScopeSyntax.swift

@@ -18,7 +18,7 @@ import SwiftSyntax
 
 @_spi(Experimental) extension TypeScopeSyntax {
   public var implicitInstanceAndTypeNames: [LookupName] {
-    [.self(self), .Self(self)]
+    [.implicit(.self(self)), .implicit(.Self(self))]
   }
 
   public var introducedNames: [LookupName] {

Tests/SwiftLexicalLookupTest/ExpectedName.swift

@@ -25,42 +25,60 @@ extension String: ExpectedName {
   }
 }
 
+enum ImplicitNameExpectation {
+  case `self`(String)
+  case `Self`(String)
+  case error(String)
+  case newValue(String)
+  case oldValue(String)
+  
+  func assertExpectation(marker: String, for name: LookupImplicitNameKind) {
+    switch (name, self) {
+    case (.self, .self): break
+    case (.Self, .Self): break
+    case (.error, .error): break
+    case (.newValue, .newValue): break
+    case (.oldValue, .oldValue): break
+    default:
+      XCTFail("For marker \(marker), actual name kind \(name) doesn't match expected \(self)")
+    }
+  }
+  
+  var marker: String {
+    switch self {
+    case .self(let marker),
+      .Self(let marker),
+      .error(let marker),
+      .newValue(let marker),
+      .oldValue(let marker):
+      marker
+    }
+  }
+}
+
 /// Can be used to optionally assert
 /// exact lookup name kind.
 enum NameExpectation: ExpectedName {
   case identifier(String)
   case declaration(String)
-  case selfInstance(String)
-  case selfType(String)
-  case selfCaptured(String)
-  case error(String)
-  case newValue(String)
-  case oldValue(String)
+  case implicit(ImplicitNameExpectation)
 
   var marker: String {
     switch self {
     case .identifier(let marker),
-      .declaration(let marker),
-      .selfInstance(let marker),
-      .selfType(let marker),
-      .selfCaptured(let marker),
-      .error(let marker),
-      .newValue(let marker),
-      .oldValue(let marker):
+        .declaration(let marker):
       marker
+    case .implicit(let implicitName):
+      implicitName.marker
     }
   }
 
   private func assertExpectation(marker: String, for name: LookupName) {
     switch (name, self) {
     case (.identifier, .identifier): break
     case (.declaration, .declaration): break
-    case (.self, .selfInstance): break
-    case (.Self, .selfType): break
-    case (.selfCaptured, .selfCaptured): break
-    case (.error, .error): break
-    case (.newValue, .newValue): break
-    case (.oldValue, .oldValue): break
+    case (.implicit(let implicitName), .implicit(let implicitNameExpectation)):
+      implicitNameExpectation.assertExpectation(marker: marker, for: implicitName)
     default:
       XCTFail("For marker \(marker), actual name kind \(name) doesn't match expected \(self)")
     }

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -150,8 +150,8 @@ final class testNameLookup: XCTestCase {
         """,
       references: [
         "5️⃣": [
-          .fromScope(ClosureExprSyntax.self, expectedNames: [NameExpectation.selfCaptured("2️⃣")]),
-          .fromScope(ClassDeclSyntax.self, expectedNames: [NameExpectation.selfInstance("7️⃣")]),
+          .fromScope(ClosureExprSyntax.self, expectedNames: [NameExpectation.implicit(.self("2️⃣"))]),
+          .fromScope(ClassDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("7️⃣"))]),
         ],
         "6️⃣": [
           .fromScope(ClosureExprSyntax.self, expectedNames: ["3️⃣"]),
@@ -412,7 +412,7 @@ final class testNameLookup: XCTestCase {
           .fromScope(MemberBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣", "3️⃣"]),
           .fromScope(
             ClassDeclSyntax.self,
-            expectedNames: [NameExpectation.selfInstance("🔟"), NameExpectation.selfType("🔟")]
+            expectedNames: [NameExpectation.implicit(.self("🔟")), NameExpectation.implicit(.Self("🔟"))]
           ),
           .fromFileScope(expectedNames: ["🔟"]),
         ],
@@ -423,7 +423,7 @@ final class testNameLookup: XCTestCase {
           .fromScope(MemberBlockSyntax.self, expectedNames: ["1️⃣", "2️⃣", "3️⃣"]),
           .fromScope(
             ClassDeclSyntax.self,
-            expectedNames: [NameExpectation.selfInstance("🔟"), NameExpectation.selfType("🔟")]
+            expectedNames: [NameExpectation.implicit(.self("🔟")), NameExpectation.implicit(.Self("🔟"))]
           ),
           .fromFileScope(expectedNames: ["🔟"]),
         ],
@@ -651,15 +651,15 @@ final class testNameLookup: XCTestCase {
         """,
       references: [
         "3️⃣": [
-          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.selfType("2️⃣")]),
-          .fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.selfType("1️⃣")]),
+          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.implicit(.Self("2️⃣"))]),
+          .fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.Self("1️⃣"))]),
         ],
         "4️⃣": [
-          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.selfInstance("2️⃣")]),
-          .fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.selfInstance("1️⃣")]),
+          .fromScope(StructDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("2️⃣"))]),
+          .fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("1️⃣"))]),
         ],
-        "5️⃣": [.fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.selfType("1️⃣")])],
-        "6️⃣": [.fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.selfInstance("1️⃣")])],
+        "5️⃣": [.fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.Self("1️⃣"))])],
+        "6️⃣": [.fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("1️⃣"))])],
       ]
     )
   }
@@ -691,10 +691,10 @@ final class testNameLookup: XCTestCase {
         }
         """,
       references: [
-        "2️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.newValue("1️⃣")])],
+        "2️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.implicit(.newValue("1️⃣"))])],
         "4️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.identifier("3️⃣")])],
-        "6️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.newValue("5️⃣")])],
-        "8️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.oldValue("7️⃣")])],
+        "6️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.implicit(.newValue("5️⃣"))])],
+        "8️⃣": [.fromScope(AccessorDeclSyntax.self, expectedNames: [NameExpectation.implicit(.oldValue("7️⃣"))])],
       ]
     )
   }