Add suggested changes.

Author: MAJKFL

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -17,7 +17,7 @@ protocol IntroducingToSequentialParentScopeSyntax: ScopeSyntax {
   /// handled by it's parent sequential scope.
   func introducesToSequentialParent(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult]

Sources/SwiftLexicalLookup/LookupName.swift

@@ -12,12 +12,17 @@
 
 import SwiftSyntax
 
-@_spi(Experimental) public enum LookupImplicitNameKind {
+/// An entity that is implicitly declared based on the syntactic structure of the program.
+@_spi(Experimental) public enum ImplicitDecl {
   /// `self` keyword representing object instance.
-  case `self`(SyntaxProtocol)
+  /// Could be associated with type declaration, extension,
+  /// or closure captures.
+  case `self`(DeclSyntaxProtocol)
   /// `Self` keyword representing object type.
+  /// Could be associated with type declaration or extension.
   case `Self`(DeclSyntaxProtocol)
-  /// `self` captured by a closure.
+  /// `error` value caught by a `catch`
+  /// block that does not specify a catch pattern.
   case error(CatchClauseSyntax)
   /// `newValue` available by default inside `set` and `willSet`.
   case newValue(AccessorDeclSyntax)
@@ -28,35 +33,58 @@ import SwiftSyntax
   @_spi(Experimental) public var syntax: SyntaxProtocol {
     switch self {
     case .self(let syntax):
-      syntax
+      return syntax
     case .Self(let syntax):
-      syntax
+      return syntax
     case .error(let syntax):
-      syntax
+      return syntax
     case .newValue(let syntax):
-      syntax
+      return syntax
     case .oldValue(let syntax):
-      syntax
+      return syntax
     }
   }
 
-  /// Name associated with implicit name kind.
+  /// The name of the implicit declaration.
   private var name: String {
     switch self {
     case .self:
-      "self"
+      return "self"
     case .Self:
-      "Self"
+      return "Self"
     case .error:
-      "error"
+      return "error"
     case .newValue:
-      "newValue"
+      return "newValue"
     case .oldValue:
-      "oldValue"
+      return "oldValue"
     }
   }
 
   /// Identifier used for name comparison.
+  ///
+  ///
+  /// ```swift
+  /// class Foo {
+  ///     func test() {
+  ///     let `Self` = "abc"
+  ///     print(Self.self)
+  ///
+  ///     let `self` = "def"
+  ///     print(self)
+  ///   }
+  /// }
+  ///
+  /// Foo().test()
+  /// ```
+  /// prints:
+  /// ```
+  /// abc
+  /// def
+  /// ```
+  /// `self` and `Self` identifers override
+  /// implicit `self` and `Self` introduced by
+  /// the `Foo` class declaration.
   var identifier: Identifier {
     Identifier(name)
   }
@@ -70,29 +98,29 @@ import SwiftSyntax
   /// Could be class, struct, actor, protocol, function and more.
   case declaration(NamedDeclSyntax)
   /// Name introduced implicitly by certain syntax nodes.
-  case implicit(LookupImplicitNameKind)
+  case implicit(ImplicitDecl)
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
     switch self {
     case .identifier(let syntax, _):
-      syntax
+      return syntax
     case .declaration(let syntax):
-      syntax
+      return syntax
     case .implicit(let implicitName):
-      implicitName.syntax
+      return implicitName.syntax
     }
   }
 
   /// Identifier used for name comparison.
   @_spi(Experimental) public var identifier: Identifier? {
     switch self {
     case .identifier(let syntax, _):
-      Identifier(syntax.identifier)
+      return Identifier(syntax.identifier) ?? Identifier(syntax.identifier.text)
     case .declaration(let syntax):
-      Identifier(syntax.name)
+      return Identifier(syntax.name)
     case .implicit(let kind):
-      kind.identifier
+      return kind.identifier
     }
   }
 
@@ -177,11 +205,7 @@ import SwiftSyntax
     identifiable: IdentifiableSyntax,
     accessibleAfter: AbsolutePosition? = nil
   ) -> [LookupName] {
-    if let closureCapture = identifiable as? ClosureCaptureSyntax,
-      closureCapture.identifier.tokenKind == .keyword(.self)
-    {
-      return [.implicit(.self(closureCapture))]  // Handle `self` closure capture.
-    } else if identifiable.identifier.tokenKind != .wildcard {
+    if identifiable.identifier.tokenKind != .wildcard {
       return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     } else {
       return []

Sources/SwiftLexicalLookup/LookupState.swift

@@ -12,6 +12,8 @@
 
 import Foundation
 
+/// Represents internal state for lookup.
+/// It shouldn't be used by clients.
 @_spi(Experimental) public struct LookupState {
   /// Specifies scopes that introduce names to their parent and
   /// should be skipped during lookup in sequential scopes.

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -98,21 +98,21 @@ import SwiftSyntax
   /// - for `codeBlock` - a
   @_spi(Experimental) public func _lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     switch config.fileScopeHandling {
     case .memberBlock:
       let names = introducedNames(using: .memberBlock)
         .filter { lookupName in
-          checkName(identifier, refersTo: lookupName, at: syntax)
+          checkName(identifier, refersTo: lookupName, at: origin)
         }
 
       return names.isEmpty ? [] : [.fromFileScope(self, withNames: names)]
     case .memberBlockUpToLastDecl:
-      var members = [LookupName]()
-      var sequentialItems = [CodeBlockItemSyntax]()
+      var members: [LookupName] = []
+      var sequentialItems: [CodeBlockItemSyntax] = []
       var encounteredNonDeclaration = false
 
       for codeBlockItem in statements {
@@ -124,7 +124,7 @@ import SwiftSyntax
           if item.is(DeclSyntax.self) || item.is(VariableDeclSyntax.self) {
             let foundNames = LookupName.getNames(from: item)
 
-            members.append(contentsOf: foundNames.filter { checkName(identifier, refersTo: $0, at: syntax) })
+            members.append(contentsOf: foundNames.filter { checkName(identifier, refersTo: $0, at: origin) })
           } else {
             encounteredNonDeclaration = true
             sequentialItems.append(codeBlockItem)
@@ -135,7 +135,7 @@ import SwiftSyntax
       let sequentialNames = sequentialLookup(
         in: sequentialItems,
         for: identifier,
-        at: syntax,
+        at: origin,
         with: config,
         state: state,
         createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
@@ -157,14 +157,14 @@ import SwiftSyntax
 
   @_spi(Experimental) public func _lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     sequentialLookup(
       in: statements,
       for: identifier,
-      at: syntax,
+      at: origin,
       with: config,
       state: state,
       createResultsForThisScopeWith: { .fromScope(self, withNames: $0) }
@@ -279,14 +279,14 @@ import SwiftSyntax
   /// ```
   @_spi(Experimental) public func _lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
-    if let elseBody, elseBody.position <= syntax.position, elseBody.endPosition >= syntax.position {
-      return lookupInParent(for: identifier, at: syntax, with: config, state: state)
+    if let elseBody, elseBody.position <= origin.position, elseBody.endPosition >= origin.position {
+      return lookupInParent(for: identifier, at: origin, with: config, state: state)
     } else {
-      return defaultLookupImplementation(for: identifier, at: syntax, with: config, state: state)
+      return defaultLookupImplementation(for: identifier, at: origin, with: config, state: state)
     }
   }
 }
@@ -303,14 +303,14 @@ import SwiftSyntax
 @_spi(Experimental) extension GuardStmtSyntax: IntroducingToSequentialParentScopeSyntax {
   @_spi(Experimental) public func introducesToSequentialParent(
     for identifier: Identifier?,
-    at syntax: SwiftSyntax.SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     let names = conditions.flatMap { element in
       LookupName.getNames(from: element.condition, accessibleAfter: element.endPosition)
     }.filter { introducedName in
-      checkName(identifier, refersTo: introducedName, at: syntax)
+      checkName(identifier, refersTo: introducedName, at: origin)
     }
 
     return names.isEmpty ? [] : [.fromScope(self, withNames: names)]
@@ -333,16 +333,16 @@ import SwiftSyntax
   /// ```
   @_spi(Experimental) public func _lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
-    if body.position <= syntax.position && body.endPosition >= syntax.position {
+    if body.position <= origin.position && body.endPosition >= origin.position {
       var newState = state
       newState.skipSequentialIntroductionFrom = self
-      return lookupInParent(for: identifier, at: syntax, with: config, state: newState)
+      return lookupInParent(for: identifier, at: origin, with: config, state: newState)
     } else {
-      return defaultLookupImplementation(for: identifier, at: syntax, with: config, state: state)
+      return defaultLookupImplementation(for: identifier, at: origin, with: config, state: state)
     }
   }
 }

Sources/SwiftLexicalLookup/ScopeSyntax.swift

@@ -56,21 +56,14 @@ extension SyntaxProtocol {
   var parentScope: ScopeSyntax? { get }
   /// Names found in this scope. Ordered from first to last introduced.
   var introducedNames: [LookupName] { get }
-  /// Finds all declarations `name` refers to. `syntax` specifies the node lookup was triggered with.
-  /// If `name` set to `nil`, returns all available names at the given node.
-  func lookup(
-    for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
-    with config: LookupConfig
-  ) -> [LookupResult]
-  /// Finds all declarations `name` refers to. `syntax` specifies the node lookup was triggered with.
-  /// If `name` set to `nil`, returns all available names at the given node.
+  /// Finds all declarations `identifier` refers to. `syntax` specifies the node lookup was triggered with.
+  /// If `identifier` set to `nil`, returns all available names at the given node.
   /// `state` represents lookup state passed between lookup methods.
   ///
   /// - Note: This method is intended for internal use only. For public usage, use ``ScopeSyntax/lookup(for:at:with:)`` instead.
   func _lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult]
@@ -81,66 +74,66 @@ extension SyntaxProtocol {
     self.parent?.scope
   }
 
-  /// Returns `LookupResult` of all names introduced in this scope that `name`
+  /// Returns `LookupResult` of all names introduced in this scope that `identifier`
   /// refers to and is accessible at given syntax node then passes lookup to the parent.
-  /// If `name` set to `nil`, returns all available names at the given node.
+  /// If `identifier` set to `nil`, returns all available names at the given node.
   /// `state` represents lookup state passed between lookup methods.
   ///
   /// - Note: This method is intended for internal use only. For public usage, use ``ScopeSyntax/lookup(for:at:with:)`` instead.
   @_spi(Experimental) public func _lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
-    defaultLookupImplementation(for: identifier, at: syntax, with: config, state: state)
+    defaultLookupImplementation(for: identifier, at: origin, with: config, state: state)
   }
-  
-  /// Returns `LookupResult` of all names introduced in this scope that `name`
+
+  /// Returns `LookupResult` of all names introduced in this scope that `identifier`
   /// refers to and is accessible at given syntax node then passes lookup to the parent.
-  /// If `name` set to `nil`, returns all available names at the given node.
+  /// If `identifier` set to `nil`, returns all available names at the given node.
   @_spi(Experimental) public func lookup(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig
   ) -> [LookupResult] {
-    _lookup(for: identifier, at: syntax, with: config, state: LookupState())
+    _lookup(for: identifier, at: origin, with: config, state: LookupState())
   }
 
-  /// Returns `LookupResult` of all names introduced in this scope that `name`
+  /// Returns `LookupResult` of all names introduced in this scope that `identifier`
   /// refers to and is accessible at given syntax node then passes lookup to the parent.
-  /// If `name` set to `nil`, returns all available names at the given node.
+  /// If `identifier` set to `nil`, returns all available names at the given node.
   func defaultLookupImplementation(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
     let filteredNames =
       introducedNames
       .filter { introducedName in
-        checkName(identifier, refersTo: introducedName, at: syntax)
+        checkName(identifier, refersTo: introducedName, at: origin)
       }
 
     if filteredNames.isEmpty {
-      return lookupInParent(for: identifier, at: syntax, with: config, state: state)
+      return lookupInParent(for: identifier, at: origin, with: config, state: state)
     } else {
       return [.fromScope(self, withNames: filteredNames)]
-        + lookupInParent(for: identifier, at: syntax, with: config, state: state)
+        + lookupInParent(for: identifier, at: origin, with: config, state: state)
     }
   }
 
   /// Looks up in parent scope.
   func lookupInParent(
     for identifier: Identifier?,
-    at syntax: SyntaxProtocol,
+    at origin: SyntaxProtocol,
     with config: LookupConfig,
     state: LookupState
   ) -> [LookupResult] {
-    parentScope?._lookup(for: identifier, at: syntax, with: config, state: state) ?? []
+    parentScope?._lookup(for: identifier, at: origin, with: config, state: state) ?? []
   }
 
-  func checkName(_ name: Identifier?, refersTo introducedName: LookupName, at syntax: SyntaxProtocol) -> Bool {
-    introducedName.isAccessible(at: syntax) && (name == nil || introducedName.refersTo(name!))
+  func checkName(_ name: Identifier?, refersTo introducedName: LookupName, at origin: SyntaxProtocol) -> Bool {
+    introducedName.isAccessible(at: origin) && (name == nil || introducedName.refersTo(name!))
   }
 }