Add sequential handling of subscript and switch case scopes. Remove wild card filtering.

Author: MAJKFL

Sources/SwiftLexicalLookup/LookupName.swift

@@ -17,7 +17,7 @@ import SwiftSyntax
   /// `self` keyword representing object instance.
   /// Could be associated with type declaration, extension,
   /// or closure captures. Introduced at function edge.
-  case `self`(FunctionDeclSyntax)
+  case `self`(DeclSyntaxProtocol)
   /// `Self` keyword representing object type.
   /// Could be associated with type declaration or extension.
   case `Self`(DeclSyntaxProtocol)
@@ -136,7 +136,7 @@ import SwiftSyntax
   }
 
   /// Position of this name.
-  /// 
+  ///
   /// For some syntax nodes, their position doesn't reflect
   /// the position at which a particular name was introduced at.
   /// Such cases are function parameters (as they can
@@ -145,21 +145,24 @@ import SwiftSyntax
   @_spi(Experimental) public var position: AbsolutePosition {
     switch self {
     case .identifier(let syntax, _):
-      switch Syntax(syntax).as(SyntaxEnum.self) {
-      case .functionParameter(let functionParameter):
-        return functionParameter.secondName?.positionAfterSkippingLeadingTrivia
-          ?? functionParameter.firstName.positionAfterSkippingLeadingTrivia
-      default:
-        return syntax.position
-      }
+      return syntax.identifier.positionAfterSkippingLeadingTrivia
     case .declaration(let syntax):
       return syntax.name.position
     case .implicit(let implicitName):
       switch implicitName {
-      case .self(let functionDecl):
-        return functionDecl.name.position
+      case .self(let declSyntax):
+        switch Syntax(declSyntax).as(SyntaxEnum.self) {
+        case .functionDecl(let functionDecl):
+          return functionDecl.name.position
+        case .subscriptDecl(let subscriptDecl):
+          return subscriptDecl.accessorBlock?.position ?? subscriptDecl.endPosition
+        default:
+          return declSyntax.positionAfterSkippingLeadingTrivia
+        }
+      case .error(let catchClause):
+        return catchClause.body.position
       default:
-        return implicitName.syntax.position
+        return implicitName.syntax.positionAfterSkippingLeadingTrivia
       }
     }
   }
@@ -195,7 +198,7 @@ import SwiftSyntax
   ) -> [LookupName] {
     switch Syntax(syntax).as(SyntaxEnum.self) {
     case .variableDecl(let variableDecl):
-      return variableDecl.bindings.flatMap { binding in
+      return variableDecl.bindings.reversed().flatMap { binding in
         getNames(
           from: binding.pattern,
           accessibleAfter: accessibleAfter != nil ? binding.endPositionBeforeTrailingTrivia : nil
@@ -239,12 +242,7 @@ import SwiftSyntax
     identifiable: IdentifiableSyntax,
     accessibleAfter: AbsolutePosition? = nil
   ) -> [LookupName] {
-    switch identifiable.identifier.tokenKind {
-    case .wildcard:
-      return []
-    default:
-      return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
-    }
+    [.identifier(identifiable, accessibleAfter: accessibleAfter)]
   }
 
   /// Extracts name introduced by `NamedDeclSyntax` node.

Sources/SwiftLexicalLookup/Scopes/NominalTypeDeclSyntax.swift

@@ -13,6 +13,7 @@
 import SwiftSyntax
 
 protocol NominalTypeDeclSyntax: LookInMembersScopeSyntax, NamedDeclSyntax, WithGenericParametersScopeSyntax {
+  var genericParameterClause: GenericParameterClauseSyntax? { get }
   var inheritanceClause: InheritanceClauseSyntax? { get }
 }
 
@@ -35,6 +36,10 @@ extension NominalTypeDeclSyntax {
   ) -> [LookupResult] {
     if let inheritanceClause, inheritanceClause.range.contains(lookUpPosition) {
       return lookupInParent(identifier, at: lookUpPosition, with: config)
+    } else if let genericParameterClause, genericParameterClause.range.contains(lookUpPosition) {
+      return lookupInParent(identifier, at: lookUpPosition, with: config)
+    } else if name.range.contains(lookUpPosition) {
+      return lookupInParent(identifier, at: lookUpPosition, with: config)
     } else {
       return [.lookInMembers(self)] + lookupInParent(identifier, at: lookUpPosition, with: config)
     }

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -191,6 +191,21 @@ import SwiftSyntax
   @_spi(Experimental) public var scopeDebugName: String {
     "ForStmtScope"
   }
+
+  /// Returns results with names matching lookup.
+  /// Doesn't include names introduced at this scope
+  /// if lookup started inside it's `pattern` or `sequence`.
+  @_spi(Experimental) public func lookup(
+    _ identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    if pattern.range.contains(lookUpPosition) || sequence.range.contains(lookUpPosition) {
+      return lookupInParent(identifier, at: lookUpPosition, with: config)
+    } else {
+      return defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
+    }
+  }
 }
 
 @_spi(Experimental) extension ClosureExprSyntax: SequentialScopeSyntax {
@@ -249,8 +264,14 @@ import SwiftSyntax
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    let filteredSignatureNames = introducedNamesInSignature.filter { name in
-      checkIdentifier(identifier, refersTo: name, at: lookUpPosition)
+    let filteredSignatureNames: [LookupName]
+
+    if let signature, signature.range.contains(lookUpPosition) {
+      filteredSignatureNames = []
+    } else {
+      filteredSignatureNames = introducedNamesInSignature.filter { name in
+        checkIdentifier(identifier, refersTo: name, at: lookUpPosition)
+      }
     }
 
     return sequentialLookup(
@@ -267,8 +288,8 @@ import SwiftSyntax
 @_spi(Experimental) extension WhileStmtSyntax: ScopeSyntax {
   /// Names introduced by the `while` loop by its conditions.
   @_spi(Experimental) public var introducedNames: [LookupName] {
-    conditions.flatMap { element in
-      LookupName.getNames(from: element.condition)
+    conditions.reversed().flatMap { element in
+      LookupName.getNames(from: element.condition, accessibleAfter: element.endPositionBeforeTrailingTrivia)
     }
   }
 
@@ -486,18 +507,26 @@ import SwiftSyntax
 @_spi(Experimental) extension AccessorDeclSyntax: ScopeSyntax {
   /// Implicit and/or explicit names introduced within the accessor.
   @_spi(Experimental) public var introducedNames: [LookupName] {
+    let names: [LookupName]
+
     if let parameters {
-      return LookupName.getNames(from: parameters)
+      names = LookupName.getNames(from: parameters)
     } else {
       switch accessorSpecifier.tokenKind {
       case .keyword(.set), .keyword(.willSet):
-        return [.implicit(.newValue(self))]
+        names = [.implicit(.newValue(self))]
       case .keyword(.didSet):
-        return [.implicit(.oldValue(self))]
+        names = [.implicit(.oldValue(self))]
       default:
-        return []
+        names = []
       }
     }
+
+    if let parentScope, parentScope.is(AccessorBlockSyntax.self) {
+      return names + [.implicit(.self(self))]
+    } else {
+      return names
+    }
   }
 
   @_spi(Experimental) public var scopeDebugName: String {
@@ -516,17 +545,47 @@ import SwiftSyntax
   }
 }
 
-@_spi(Experimental) extension SwitchCaseSyntax: ScopeSyntax {
+@_spi(Experimental) extension SwitchCaseSyntax: SequentialScopeSyntax {
   /// Names introduced within `case` items.
-  @_spi(Experimental) public var introducedNames: [LookupName] {
+  var namesFromLabel: [LookupName] {
     label.as(SwitchCaseLabelSyntax.self)?.caseItems.flatMap { child in
       LookupName.getNames(from: child.pattern)
     } ?? []
   }
 
+  /// Names introduced within `case` items
+  /// as well as sequential names from inside this case.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    statements.flatMap { codeBlockItem in
+      LookupName.getNames(from: codeBlockItem.item, accessibleAfter: codeBlockItem.endPosition)
+    } + namesFromLabel
+  }
+
   @_spi(Experimental) public var scopeDebugName: String {
     "SwitchCaseScope"
   }
+
+  /// Returns results with names matching lookup.
+  /// Includes names introduced in it's label and sequentially
+  /// introduced names from inside this case.
+  @_spi(Experimental) public func lookup(
+    _ identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    let filteredNamesFromLabel = namesFromLabel.filter { name in
+      checkIdentifier(identifier, refersTo: name, at: lookUpPosition)
+    }
+
+    return sequentialLookup(
+      in: statements,
+      identifier,
+      at: lookUpPosition,
+      with: config,
+      propagateToParent: false
+    ) + (filteredNamesFromLabel.isEmpty ? [] : [.fromScope(self, withNames: filteredNamesFromLabel)])
+      + lookupInParent(identifier, at: lookUpPosition, with: config)
+  }
 }
 
 @_spi(Experimental) extension ProtocolDeclSyntax: ScopeSyntax {
@@ -631,16 +690,83 @@ import SwiftSyntax
 }
 
 @_spi(Experimental) extension SubscriptDeclSyntax: WithGenericParametersScopeSyntax {
-  /// Parameters introduced by this subscript.
+  /// Parameters introduced by this subscript and possibly `self` keyword.
   @_spi(Experimental) public var introducedNames: [LookupName] {
-    parameterClause.parameters.flatMap { parameter in
+    let parameters = parameterClause.parameters.flatMap { parameter in
       LookupName.getNames(from: parameter)
     }
+
+    if let accessorBlock, case .getter = accessorBlock.accessors {
+      return parameters + [.implicit(.self(self))]
+    } else {
+      return parameters
+    }
   }
 
   @_spi(Experimental) public var scopeDebugName: String {
     "SubscriptDeclScope"
   }
+
+  /// Lookup results from this subscript scope.
+  /// Routes to generic parameter clause scope if exists.
+  @_spi(Experimental) public func lookup(
+    _ identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    var thisScopeResults: [LookupResult] = []
+
+    if !parameterClause.range.contains(lookUpPosition) && !returnClause.range.contains(lookUpPosition) {
+      thisScopeResults = defaultLookupImplementation(
+        identifier,
+        at: position,
+        with: config,
+        propagateToParent: false
+      )
+    }
+
+    return thisScopeResults
+      + lookupThroughGenericParameterScope(
+        identifier,
+        at: lookUpPosition,
+        with: config
+      )
+  }
+}
+
+@_spi(Experimental) extension AccessorBlockSyntax: SequentialScopeSyntax {
+  /// Names from the accessors or
+  /// getters of this accessor block scope.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    switch accessors {
+    case .getter(let codeBlockItems):
+      return codeBlockItems.flatMap { codeBlockItem in
+        LookupName.getNames(from: codeBlockItem.item)
+      }
+    case .accessors:
+      return []
+    }
+  }
+
+  @_spi(Experimental) public var scopeDebugName: String {
+    "AccessorBlockScope"
+  }
+
+  /// Names introduced in this accessir block scope.
+  /// If `accessor` is of `.getter` kind, introduced
+  /// it's items sequentially. Otherwise, propagate to parent.
+  @_spi(Experimental) public func lookup(
+    _ identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    switch accessors {
+    case .getter(let codeBlockItems):
+      return sequentialLookup(in: codeBlockItems, identifier, at: lookUpPosition, with: config)
+    case .accessors:
+      return lookupInParent(identifier, at: lookUpPosition, with: config)
+    }
+  }
 }
 
 @_spi(Experimental) extension TypeAliasDeclSyntax: WithGenericParametersScopeSyntax {

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -633,7 +633,7 @@ final class testNameLookup: XCTestCase {
     )
   }
 
-  func testGuardOnFileScope() {
+  func testGuardOnFileScope() {  // TODO: Fix this according to ASTScope (ommiting class a)
     assertLexicalNameLookup(
       source: """
         let 1️⃣a = 0
@@ -902,7 +902,7 @@ final class testNameLookup: XCTestCase {
     )
   }
 
-  func testSwitchExpression() {
+  func testSwitchExpression() {  // TODO: For some reason ASTScope doesn't introduce any results besides first function call expr.
     assertLexicalNameLookup(
       source: """
         switch {
@@ -973,20 +973,16 @@ final class testNameLookup: XCTestCase {
         """,
       references: [
         "2️⃣": [
-          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["1️⃣"]),
-          .lookInMembers(ClassDeclSyntax.self),
+          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["1️⃣"])
         ],
         "3️⃣": [
-          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["1️⃣"]),
-          .lookInMembers(ClassDeclSyntax.self),
+          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["1️⃣"])
         ],
         "5️⃣": [
-          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["7️⃣"]),
-          .lookInMembers(ClassDeclSyntax.self),
+          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["7️⃣"])
         ],
         "6️⃣": [
-          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["4️⃣"]),
-          .lookInMembers(ClassDeclSyntax.self),
+          .fromScope(GenericParameterClauseSyntax.self, expectedNames: ["4️⃣"])
         ],
       ],
       expectedResultTypes: .all(GenericParameterSyntax.self)
@@ -1070,7 +1066,7 @@ final class testNameLookup: XCTestCase {
     )
   }
 
-  func testSubscript() {
+  func testSubscript() {  // TODO: Fix behavior of self keyword in subscript with accessors.
     assertLexicalNameLookup(
       source: """
         class X {