Add implicit names and proper guard handling.

Author: MAJKFL

Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -19,13 +19,13 @@ import Foundation
 
   /// Specifies scopes that introduce names to their parent and
   /// should be skipped during lookup in sequential scopes.
-  public var ignoreChildrenToParentIntroductionsFrom: [IntroducingToParentScopeSyntax]
+  public var ignoreChildrenToSequentialParentIntroductionsFrom: [IntroducingToSequentialParentScopeSyntax]
 
   public init(
     fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl,
-    ignoreChildrenToParentIntroductionsFrom: [IntroducingToParentScopeSyntax] = []
+    ignoreChildrenToSequentialParentIntroductionsFrom: [IntroducingToSequentialParentScopeSyntax] = []
   ) {
     self.fileScopeHandling = fileScopeHandling
-    self.ignoreChildrenToParentIntroductionsFrom = ignoreChildrenToParentIntroductionsFrom
+    self.ignoreChildrenToSequentialParentIntroductionsFrom = ignoreChildrenToSequentialParentIntroductionsFrom
   }
 }

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -41,3 +41,9 @@ extension ClosureCaptureSyntax: IdentifiableSyntax {
     expression.as(DeclReferenceExprSyntax.self)!.baseName
   }
 }
+
+extension AccessorParametersSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: TokenSyntax {
+    name
+  }
+}

Sources/SwiftLexicalLookup/IntroducingToParentScopeSyntax.swift renamed to Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -12,8 +12,10 @@
 
 import SwiftSyntax
 
-@_spi(Experimental) public protocol IntroducingToParentScopeSyntax: ScopeSyntax {
-  func introducedToParent(
+@_spi(Experimental) public 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

Sources/SwiftLexicalLookup/LookupName.swift

@@ -19,6 +19,18 @@ import SwiftSyntax
   /// Declaration associated with the name.
   /// Could be class, struct, actor, protocol, function and more
   case declaration(NamedDeclSyntax, accessibleAfter: AbsolutePosition?)
+  /// `self` keyword representing object instance.
+  case `self`(DeclSyntaxProtocol)
+  /// `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 {
@@ -27,6 +39,18 @@ import SwiftSyntax
       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):
+      syntax
+    case .oldValue(let syntax):
+      syntax
     }
   }
 
@@ -37,6 +61,8 @@ import SwiftSyntax
       Identifier(syntax.identifier)
     case .declaration(let syntax, _):
       Identifier(syntax.name)
+    default:
+      nil
     }
   }
 
@@ -46,6 +72,26 @@ 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 .self, .selfCaptured:
+      "self"
+    case .Self:
+      "Self"
+    case .error:
+      "error"
+    case .newValue:
+      "newValue"
+    case .oldValue:
+      "oldValue"
     }
   }
 
@@ -57,7 +103,7 @@ 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
   }
 
@@ -104,7 +150,11 @@ import SwiftSyntax
   /// Extracts name introduced by `IdentifiableSyntax` node.
   private static func handle(identifiable: IdentifiableSyntax, accessibleAfter: AbsolutePosition? = nil) -> [LookupName]
   {
-    if identifiable.identifier.text != "_" {
+    if let closureCapture = identifiable as? ClosureCaptureSyntax,
+      closureCapture.identifier.tokenKind == .keyword(.self)
+    {
+      return [.selfCaptured(closureCapture)]  // Handle `self` closure capture.
+    } else if identifiable.identifier.text != "_" {
       return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     } else {
       return []

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -309,8 +309,8 @@ extension SyntaxProtocol {
   }
 }
 
-@_spi(Experimental) extension GuardStmtSyntax: IntroducingToParentScopeSyntax {
-  public func introducedToParent(
+@_spi(Experimental) extension GuardStmtSyntax: IntroducingToSequentialParentScopeSyntax {
+  public func introducesToSequentialParent(
     for name: String?,
     at syntax: SwiftSyntax.SyntaxProtocol,
     with config: LookupConfig
@@ -346,10 +346,33 @@ extension SyntaxProtocol {
   ) -> [LookupResult] {
     if body.position <= syntax.position && body.endPosition >= syntax.position {
       var newConfig = config
-      newConfig.ignoreChildrenToParentIntroductionsFrom.append(self)
+      newConfig.ignoreChildrenToSequentialParentIntroductionsFrom.append(self)
       return lookupInParent(for: name, at: syntax, with: newConfig)
     } else {
       return defaultLookupImplementation(for: name, at: syntax, with: config)
     }
   }
 }
+
+@_spi(Experimental) extension ActorDeclSyntax: TypeScopeSyntax {}
+@_spi(Experimental) extension ClassDeclSyntax: TypeScopeSyntax {}
+@_spi(Experimental) extension StructDeclSyntax: TypeScopeSyntax {}
+@_spi(Experimental) extension EnumDeclSyntax: TypeScopeSyntax {}
+@_spi(Experimental) extension ExtensionDeclSyntax: TypeScopeSyntax {}
+
+@_spi(Experimental) extension AccessorDeclSyntax: ScopeSyntax {
+  public var introducedNames: [LookupName] {
+    if let parameters {
+      LookupName.getNames(from: parameters)
+    } else {
+      switch accessorSpecifier.tokenKind {
+      case .keyword(.set), .keyword(.willSet):
+        [.newValue(self)]
+      case .keyword(.didSet):
+        [.oldValue(self)]
+      default:
+        []
+      }
+    }
+  }
+}

Sources/SwiftLexicalLookup/SequentialScopeSyntax.swift

@@ -12,7 +12,13 @@
 
 import SwiftSyntax
 
+/// Scope that, in addition to names introduced by itself,
+/// also handles names introduced by
+/// `IntroducingToSequentialParentScopeSyntax` children scopes.
 @_spi(Experimental) public protocol SequentialScopeSyntax: ScopeSyntax {
+  /// Returns names introduced by `codeBlockItems`
+  /// and included `IntroducingToSequentialParentScopeSyntax` children
+  /// scopes that match the lookup.
   func sequentialLookup(
     in codeBlockItems: any Collection<CodeBlockItemSyntax>,
     for name: String?,
@@ -35,9 +41,12 @@ import SwiftSyntax
 
     for codeBlockItem in codeBlockItems {
       if let introducingToParentScope = Syntax(codeBlockItem.item).asProtocol(SyntaxProtocol.self)
-        as? IntroducingToParentScopeSyntax
+        as? IntroducingToSequentialParentScopeSyntax
       {
-        guard !config.ignoreChildrenToParentIntroductionsFrom.contains(where: { $0.id == introducingToParentScope.id })
+        guard
+          !config.ignoreChildrenToSequentialParentIntroductionsFrom.contains(where: {
+            $0.id == introducingToParentScope.id
+          })
         else {
           continue
         }
@@ -47,7 +56,9 @@ import SwiftSyntax
           currentChunk = []
         }
 
-        result.append(contentsOf: introducingToParentScope.introducedToParent(for: name, at: syntax, with: config))
+        result.append(
+          contentsOf: introducingToParentScope.introducesToSequentialParent(for: name, at: syntax, with: config)
+        )
       } else {
         currentChunk.append(
           contentsOf:

Sources/SwiftLexicalLookup/TypeScopeSyntax.swift

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+@_spi(Experimental) public protocol TypeScopeSyntax: ScopeSyntax, DeclSyntaxProtocol {
+  var implicitInstanceAndTypeNames: [LookupName] { get }
+}
+
+@_spi(Experimental) extension TypeScopeSyntax {
+  public var implicitInstanceAndTypeNames: [LookupName] {
+    [.self(self), .Self(self)]
+  }
+
+  public var introducedNames: [LookupName] {
+    implicitInstanceAndTypeNames
+  }
+}

Tests/SwiftLexicalLookupTest/Assertions.swift

@@ -10,84 +10,12 @@
 //
 //===----------------------------------------------------------------------===//
 
-import Foundation
 @_spi(Experimental) import SwiftLexicalLookup
 import SwiftParser
 import SwiftSyntax
 import XCTest
 import _SwiftSyntaxTestSupport
 
-/// Used to define result type expectectations for given markers.
-enum MarkerExpectation {
-  /// Specifies a separate type for each result marker.
-  case distinct([String: SyntaxProtocol.Type])
-  /// Specifies a common type for all results
-  /// apart from the ones defined explicitly in `except`.
-  case all(SyntaxProtocol.Type, except: [String: SyntaxProtocol.Type] = [:])
-  /// Does not assert result types.
-  case none
-
-  /// Assert `actual` result labeled with `marker`
-  /// according to the rules represented by this expectation.
-  fileprivate func assertMarkerType(marker: String, actual: SyntaxProtocol) {
-    switch self {
-    case .all(let expectedType, except: let dictionary):
-      assertMarkerType(marker: marker, actual: actual, expectedType: dictionary[marker] ?? expectedType)
-    case .distinct(let dictionary):
-      if let expectedType = dictionary[marker] {
-        assertMarkerType(marker: marker, actual: actual, expectedType: expectedType)
-      } else {
-        XCTFail("For result \(marker), could not find type expectation")
-      }
-    case .none:
-      break
-    }
-  }
-
-  /// Assert whether `actual` type matches `expectedType`.
-  private func assertMarkerType(marker: String, actual: SyntaxProtocol, expectedType: SyntaxProtocol.Type) {
-    XCTAssert(
-      actual.is(expectedType),
-      "For result \(marker), expected type \(expectedType) doesn't match the actual type \(actual.syntaxNodeType)"
-    )
-  }
-}
-
-/// Used to define
-enum ResultExpectation {
-  case fromScope(ScopeSyntax.Type, expectedNames: [String])
-  case fromFileScope(expectedNames: [String])
-
-  var expectedNames: [String] {
-    switch self {
-    case .fromScope(_, let expectedNames):
-      expectedNames
-    case .fromFileScope(expectedNames: let expectedNames):
-      expectedNames
-    }
-  }
-
-  var debugDescription: String {
-    switch self {
-    case .fromScope:
-      "fromScope"
-    case .fromFileScope:
-      "fromFileScope"
-    }
-  }
-}
-
-extension LookupResult {
-  var debugDescription: String {
-    switch self {
-    case .fromScope:
-      "fromScope"
-    case .fromFileScope:
-      "fromFileScope"
-    }
-  }
-}
-
 /// `methodUnderTest` is called with the token at every position marker in the keys of `expected`.
 /// It then asserts that the positions of the syntax nodes returned by `methodUnderTest` are the values in `expected`.
 /// It also checks whether result types match rules specified in `expectedResultTypes`.
@@ -185,21 +113,7 @@ func assertLexicalNameLookup(
         return []
       }
 
-      for (actual, expected) in zip(result, expectedValues) {
-        switch (actual, expected) {
-        case (.fromScope(let scope, withNames: _), .fromScope(let expectedType, expectedNames: _)):
-          XCTAssert(
-            scope.syntaxNodeType == expectedType,
-            "For marker \(marker), scope result type of \(scope.syntaxNodeType) doesn't match expected \(expectedType)"
-          )
-        case (.fromFileScope, .fromFileScope):
-          break
-        default:
-          XCTFail(
-            "For marker \(marker), actual result kind \(actual.debugDescription) doesn't match expected \(expected.debugDescription)"
-          )
-        }
-      }
+      ResultExpectation.assertResult(marker: marker, result: result, expectedValues: expectedValues)
 
       return result.flatMap { lookUpResult in
         lookUpResult.names.map { lookupName in
@@ -209,7 +123,9 @@ func assertLexicalNameLookup(
     },
     expected: references.mapValues { expectations in
       expectations.flatMap { expectation in
-        expectation.expectedNames
+        expectation.expectedNames.map { expectedName in
+          expectedName.marker
+        }
       }
     },
     expectedResultTypes: expectedResultTypes