Add suggestions

Author: MAJKFL

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -13,12 +13,14 @@
 import SwiftSyntax
 
 protocol IntroducingToSequentialParentScopeSyntax: ScopeSyntax {
-  /// Returns names matching lookup that should be
-  /// handled by it's parent sequential scope.
-  func introducesToSequentialParent(
+  /// Returns all names introduced to parent.
+  var namesIntroducedToSequentialParent: [LookupName] { get }
+  
+  /// Returns results matching lookup that should be
+  /// interleaved with results of the sequential parent.
+  func lookupFromSequentialParent(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult]
 }

Sources/SwiftLexicalLookup/LookupName.swift

@@ -61,7 +61,8 @@ import SwiftSyntax
     }
   }
 
-  /// Identifier used for name comparison.
+  /// Note that `self` and `Self` are treated as identifiers for name lookup purposes 
+  /// and that a variable named `self` can shadow the `self` keyword. For example.
   ///
   ///
   /// ```swift
@@ -82,11 +83,21 @@ import SwiftSyntax
   /// abc
   /// def
   /// ```
-  /// `self` and `Self` identifers override
-  /// implicit `self` and `Self` introduced by
+  /// `self` and `Self` identifers override implicit `self` and `Self` introduced by
   /// the `Foo` class declaration.
   var identifier: Identifier {
-    Identifier(name)
+    switch self {
+    case .self:
+      return Identifier("self")
+    case .Self:
+      return Identifier("Self")
+    case .error:
+      return Identifier("error")
+    case .newValue:
+      return Identifier("newValue")
+    case .oldValue:
+      return Identifier("oldValue")
+    }
   }
 }
 
@@ -99,6 +110,10 @@ import SwiftSyntax
   case declaration(NamedDeclSyntax)
   /// Name introduced implicitly by certain syntax nodes.
   case implicit(ImplicitDecl)
+  /// Explicit `self` keyword.
+  case `self`(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
+  /// Explicit `Self` keyword.
+  case `Self`(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
@@ -109,36 +124,44 @@ import SwiftSyntax
       return syntax
     case .implicit(let implicitName):
       return implicitName.syntax
+    case .self(let syntax, _), .Self(let syntax, _):
+      return syntax
     }
   }
 
   /// Identifier used for name comparison.
   @_spi(Experimental) public var identifier: Identifier? {
     switch self {
     case .identifier(let syntax, _):
-      return Identifier(syntax.identifier) ?? Identifier(syntax.identifier.text)
+      return Identifier(syntax.identifier)
     case .declaration(let syntax):
       return Identifier(syntax.name)
     case .implicit(let kind):
       return kind.identifier
+    case .self:
+      return Identifier("self")
+    case .Self:
+      return Identifier("Self")
     }
   }
 
   /// Point, after which the name is available in scope.
   /// If set to `nil`, the name is available at any point in scope.
   var accessibleAfter: AbsolutePosition? {
     switch self {
-    case .identifier(_, let absolutePosition):
+    case .identifier(_, let absolutePosition),
+         .self(_, let absolutePosition),
+         .Self(_, let absolutePosition):
       return absolutePosition
     default:
       return nil
     }
   }
 
   /// Checks if this name was introduced before the syntax used for lookup.
-  func isAccessible(at lookedUpSyntax: SyntaxProtocol) -> Bool {
+  func isAccessible(at origin: AbsolutePosition) -> Bool {
     guard let accessibleAfter else { return true }
-    return accessibleAfter <= lookedUpSyntax.position
+    return accessibleAfter <= origin
   }
 
   /// Checks if this name refers to the looked up phrase.
@@ -205,10 +228,17 @@ import SwiftSyntax
     identifiable: IdentifiableSyntax,
     accessibleAfter: AbsolutePosition? = nil
   ) -> [LookupName] {
-    if identifiable.identifier.tokenKind != .wildcard {
-      return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
-    } else {
-      return []
+    switch identifiable.identifier.tokenKind {
+    case .keyword(.self):
+      return [.self(identifiable, accessibleAfter: accessibleAfter)]
+    case .keyword(.Self):
+      return [.Self(identifiable, accessibleAfter: accessibleAfter)]
+    default:
+      if identifiable.identifier.tokenKind != .wildcard {
+        return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
+      } else {
+        return []
+      }
     }
   }
 

Sources/SwiftLexicalLookup/LookupState.swift

@@ -96,11 +96,10 @@ import SwiftSyntax
   /// - for `memberBlockUpToLastDecl` - a, b, c, d
   /// - for `memberBlock` - a, b, c, d, e, f
   /// - for `codeBlock` - a
-  @_spi(Experimental) public func _lookup(
+  @_spi(Experimental) public func lookup(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult] {
     switch config.fileScopeHandling {
     case .memberBlock:
@@ -121,7 +120,7 @@ import SwiftSyntax
         if encounteredNonDeclaration {
           sequentialItems.append(codeBlockItem)
         } else {
-          if item.is(DeclSyntax.self) || item.is(VariableDeclSyntax.self) {
+          if item.is(DeclSyntax.self) {
             let foundNames = LookupName.getNames(from: item)
 
             members.append(contentsOf: foundNames.filter { checkName(identifier, refersTo: $0, at: origin) })
@@ -137,7 +136,6 @@ import SwiftSyntax
         for: identifier,
         at: origin,
         with: config,
-        state: state,
         createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
       )
 
@@ -155,18 +153,16 @@ import SwiftSyntax
     }
   }
 
-  @_spi(Experimental) public func _lookup(
+  @_spi(Experimental) public func lookup(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult] {
     sequentialLookup(
       in: statements,
       for: identifier,
       at: origin,
       with: config,
-      state: state,
       createResultsForThisScopeWith: { .fromScope(self, withNames: $0) }
     )
   }
@@ -277,16 +273,15 @@ import SwiftSyntax
   ///   // <-- a is not visible here
   /// }
   /// ```
-  @_spi(Experimental) public func _lookup(
+  @_spi(Experimental) public func lookup(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult] {
-    if let elseBody, elseBody.position <= origin.position, elseBody.endPosition >= origin.position {
-      return lookupInParent(for: identifier, at: origin, with: config, state: state)
+    if let elseBody, elseBody.position <= origin, elseBody.endPosition >= origin {
+      return lookupInParent(for: identifier, at: origin, with: config)
     } else {
-      return defaultLookupImplementation(for: identifier, at: origin, with: config, state: state)
+      return defaultLookupImplementation(for: identifier, at: origin, with: config)
     }
   }
 }
@@ -301,8 +296,19 @@ import SwiftSyntax
 }
 
 @_spi(Experimental) extension GuardStmtSyntax: IntroducingToSequentialParentScopeSyntax {
-  /// Returns names matching lookup.
-  /// Lookup triggered from inside of `else`
+  var namesIntroducedToSequentialParent: [LookupName] {
+    conditions.flatMap { element in
+      LookupName.getNames(from: element.condition, accessibleAfter: element.endPosition)
+    }
+  }
+  
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    []
+  }
+  
+  /// Returns results matching lookup that should be
+  /// interleaved with sequential parent's results.
+  /// Lookup triggered from within of the `else` body
   /// returns no names.
   ///
   /// Example:
@@ -312,27 +318,20 @@ import SwiftSyntax
   /// }
   /// // a is visible here
   /// ```
-  @_spi(Experimental) public func introducesToSequentialParent(
+  func lookupFromSequentialParent(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult] {
-    guard body.position > origin.position || body.endPosition < origin.position
+    guard body.position > origin || body.endPosition < origin
     else { return [] }
 
-    let names = conditions.flatMap { element in
-      LookupName.getNames(from: element.condition, accessibleAfter: element.endPosition)
-    }.filter { introducedName in
+    let names = namesIntroducedToSequentialParent.filter { introducedName in
       checkName(identifier, refersTo: introducedName, at: origin)
     }
 
     return names.isEmpty ? [] : [.fromScope(self, withNames: names)]
   }
-
-  @_spi(Experimental) public var introducedNames: [LookupName] {
-    []
-  }
 }
 
 @_spi(Experimental) extension ActorDeclSyntax: TypeScopeSyntax {}
@@ -342,8 +341,7 @@ import SwiftSyntax
 @_spi(Experimental) extension ExtensionDeclSyntax: TypeScopeSyntax {}
 
 @_spi(Experimental) extension AccessorDeclSyntax: ScopeSyntax {
-  /// Implicit and/or explicit names introduced
-  /// within the accessor.
+  /// Implicit and/or explicit names introduced within the accessor.
   @_spi(Experimental) public var introducedNames: [LookupName] {
     if let parameters {
       return LookupName.getNames(from: parameters)

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -47,7 +47,7 @@ extension SyntaxProtocol {
     for identifier: Identifier?,
     with config: LookupConfig = LookupConfig()
   ) -> [LookupResult] {
-    scope?.lookup(for: identifier, at: self, with: config) ?? []
+    scope?.lookup(for: identifier, at: self.position, with: config) ?? []
   }
 }
 
@@ -59,13 +59,10 @@ extension SyntaxProtocol {
   /// 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(
+  func lookup(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult]
 }
 
@@ -78,36 +75,21 @@ extension SyntaxProtocol {
   /// refers to and is accessible at given syntax node then passes lookup to the parent.
   /// 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 origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
-  ) -> [LookupResult] {
-    defaultLookupImplementation(for: identifier, at: origin, with: config, state: state)
-  }
-
-  /// 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 `identifier` set to `nil`, returns all available names at the given node.
   @_spi(Experimental) public func lookup(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
+    at origin: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    _lookup(for: identifier, at: origin, with: config, state: LookupState())
+    defaultLookupImplementation(for: identifier, at: origin, with: config)
   }
 
   /// 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 `identifier` set to `nil`, returns all available names at the given node.
   func defaultLookupImplementation(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult] {
     let filteredNames =
       introducedNames
@@ -116,24 +98,23 @@ extension SyntaxProtocol {
       }
 
     if filteredNames.isEmpty {
-      return lookupInParent(for: identifier, at: origin, with: config, state: state)
+      return lookupInParent(for: identifier, at: origin, with: config)
     } else {
       return [.fromScope(self, withNames: filteredNames)]
-        + lookupInParent(for: identifier, at: origin, with: config, state: state)
+        + lookupInParent(for: identifier, at: origin, with: config)
     }
   }
 
   /// Looks up in parent scope.
   func lookupInParent(
     for identifier: Identifier?,
-    at origin: SyntaxProtocol,
-    with config: LookupConfig,
-    state: LookupState
+    at origin: AbsolutePosition,
+    with config: LookupConfig
   ) -> [LookupResult] {
-    parentScope?._lookup(for: identifier, at: origin, with: config, state: state) ?? []
+    parentScope?.lookup(for: identifier, at: origin, with: config) ?? []
   }
 
-  func checkName(_ name: Identifier?, refersTo introducedName: LookupName, at origin: SyntaxProtocol) -> Bool {
+  func checkName(_ name: Identifier?, refersTo introducedName: LookupName, at origin: AbsolutePosition) -> Bool {
     introducedName.isAccessible(at: origin) && (name == nil || introducedName.refersTo(name!))
   }
 }