Add proper guard scope and implicit name lookup.

Author: MAJKFL

Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -15,9 +15,11 @@ import Foundation
 @_spi(Experimental) public struct LookupConfig {
   /// Specifies behaviour of file scope.
   /// `memberBlockUpToLastDecl` by default.
-  public var fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl
+  @_spi(Experimental) public var fileScopeHandling: FileScopeHandlingConfig
 
-  public init(fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl) {
+  @_spi(Experimental) public init(
+    fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl
+  ) {
     self.fileScopeHandling = fileScopeHandling
   }
 }

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -13,25 +13,25 @@
 import SwiftSyntax
 
 /// Syntax node that can be refered to with an identifier.
-public protocol IdentifiableSyntax: SyntaxProtocol {
+@_spi(Experimental) public protocol IdentifiableSyntax: SyntaxProtocol {
   var identifier: TokenSyntax { get }
 }
 
-extension IdentifierPatternSyntax: IdentifiableSyntax {}
+@_spi(Experimental) extension IdentifierPatternSyntax: IdentifiableSyntax {}
 
-extension ClosureParameterSyntax: IdentifiableSyntax {
+@_spi(Experimental) extension ClosureParameterSyntax: IdentifiableSyntax {
   @_spi(Experimental) public var identifier: TokenSyntax {
     secondName ?? firstName
   }
 }
 
-extension ClosureShorthandParameterSyntax: IdentifiableSyntax {
+@_spi(Experimental) extension ClosureShorthandParameterSyntax: IdentifiableSyntax {
   @_spi(Experimental) public var identifier: TokenSyntax {
     name
   }
 }
 
-extension ClosureCaptureSyntax: IdentifiableSyntax {
+@_spi(Experimental) extension ClosureCaptureSyntax: IdentifiableSyntax {
   @_spi(Experimental) public var identifier: TokenSyntax {
     /* Doesn't work with closures like:
      _ = { [y=1+2] in
@@ -41,3 +41,9 @@ extension ClosureCaptureSyntax: IdentifiableSyntax {
     expression.as(DeclReferenceExprSyntax.self)!.baseName
   }
 }
+
+@_spi(Experimental) extension AccessorParametersSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: TokenSyntax {
+    name
+  }
+}

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import SwiftSyntax
+
+protocol IntroducingToSequentialParentScopeSyntax: ScopeSyntax {
+  /// Returns names matching lookup that should be
+  /// handled by it's parent sequential scope.
+  func introducesToSequentialParent(
+    for name: String?,
+    at syntax: SyntaxProtocol,
+    with config: LookupConfig,
+    state: LookupState
+  ) -> [LookupResult]
+}

Sources/SwiftLexicalLookup/LookupName.swift

@@ -12,13 +12,60 @@
 
 import SwiftSyntax
 
+@_spi(Experimental) public enum LookupImplicitNameKind {
+  /// `self` keyword representing object instance.
+  case `self`(SyntaxProtocol)
+  /// `Self` keyword representing object type.
+  case `Self`(DeclSyntaxProtocol)
+  /// `self` captured by a closure.
+  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 .self(let syntax):
+      syntax
+    case .Self(let syntax):
+      syntax
+    case .error(let syntax):
+      syntax
+    case .newValue(let syntax):
+      syntax
+    case .oldValue(let syntax):
+      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
+  /// 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
+  /// 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 {
@@ -27,6 +74,8 @@ import SwiftSyntax
       syntax
     case .declaration(let syntax, _):
       syntax
+    case .implicit(let implicitName):
+      implicitName.syntax
     }
   }
 
@@ -37,6 +86,8 @@ import SwiftSyntax
       Identifier(syntax.identifier)
     case .declaration(let syntax, _):
       Identifier(syntax.name)
+    default:
+      nil
     }
   }
 
@@ -46,6 +97,18 @@ import SwiftSyntax
     switch self {
     case .identifier(_, let absolutePosition), .declaration(_, let absolutePosition):
       absolutePosition
+    default:
+      nil
+    }
+  }
+
+  /// Used for name comparison.
+  var name: String? {
+    switch self {
+    case .identifier, .declaration:
+      identifier?.name
+    case .implicit(let implicitName):
+      implicitName.name
     }
   }
 
@@ -57,12 +120,15 @@ import SwiftSyntax
 
   /// Checks if this name refers to the looked up phrase.
   func refersTo(_ lookedUpName: String) -> Bool {
-    guard let name = identifier?.name else { return false }
+    guard let name else { return false }
     return name == lookedUpName
   }
 
-  /// Extracts names introduced by the given `from` structure.
-  static func getNames(from syntax: SyntaxProtocol, accessibleAfter: AbsolutePosition? = nil) -> [LookupName] {
+  /// Extracts names introduced by the given `syntax` structure.
+  static func getNames(
+    from syntax: SyntaxProtocol,
+    accessibleAfter: AbsolutePosition? = nil
+  ) -> [LookupName] {
     switch Syntax(syntax).as(SyntaxEnum.self) {
     case .variableDecl(let variableDecl):
       variableDecl.bindings.flatMap { binding in
@@ -90,10 +156,6 @@ import SwiftSyntax
       functionCallExpr.arguments.flatMap { argument in
         getNames(from: argument.expression, accessibleAfter: accessibleAfter)
       }
-    case .guardStmt(let guardStmt):
-      guardStmt.conditions.flatMap { cond in
-        getNames(from: cond.condition, accessibleAfter: cond.endPosition)
-      }
     default:
       if let namedDecl = Syntax(syntax).asProtocol(SyntaxProtocol.self) as? NamedDeclSyntax {
         handle(namedDecl: namedDecl, accessibleAfter: accessibleAfter)
@@ -106,17 +168,26 @@ import SwiftSyntax
   }
 
   /// Extracts name introduced by `IdentifiableSyntax` node.
-  private static func handle(identifiable: IdentifiableSyntax, accessibleAfter: AbsolutePosition? = nil) -> [LookupName]
-  {
-    if identifiable.identifier.text != "_" {
+  private static func handle(
+    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 {
       return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     } else {
       return []
     }
   }
 
   /// Extracts name introduced by `NamedDeclSyntax` node.
-  private static func handle(namedDecl: NamedDeclSyntax, accessibleAfter: AbsolutePosition? = nil) -> [LookupName] {
+  private static func handle(
+    namedDecl: NamedDeclSyntax,
+    accessibleAfter: AbsolutePosition? = nil
+  ) -> [LookupName] {
     [.declaration(namedDecl, accessibleAfter: accessibleAfter)]
   }
 }

Sources/SwiftLexicalLookup/LookupResult.swift

@@ -12,7 +12,7 @@
 
 import SwiftSyntax
 
-/// Represents resul
+/// Represents result from a specific scope.
 @_spi(Experimental) public enum LookupResult {
   /// Scope and the names that matched lookup.
   case fromScope(ScopeSyntax, withNames: [LookupName])

Sources/SwiftLexicalLookup/LookupState.swift

@@ -0,0 +1,21 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
+// Licensed under Apache License v2.0 with Runtime Library Exception
+//
+// See https://swift.org/LICENSE.txt for license information
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Foundation
+
+@_spi(Experimental) public struct LookupState {
+  /// Specifies scopes that introduce names to their parent and
+  /// should be skipped during lookup in sequential scopes.
+  var skipSequentialIntroductionFrom: IntroducingToSequentialParentScopeSyntax?
+
+  @_spi(Experimental) public init() {}
+}