Add implicit Self to extension declaration scope. Fix name introduction of a variable with accessors in global scope. Add suggested changes and documentation.

Author: MAJKFL

Sources/SwiftLexicalLookup/LookupName.swift

@@ -20,7 +20,7 @@ import SwiftSyntax
   case `self`(DeclSyntaxProtocol)
   /// `Self` keyword representing object type.
   /// Could be associated with type declaration or extension.
-  case `Self`(ProtocolDeclSyntax)
+  case `Self`(DeclSyntaxProtocol)
   /// `error` value caught by a `catch`
   /// block that does not specify a catch pattern.
   case error(CatchClauseSyntax)
@@ -147,27 +147,33 @@ import SwiftSyntax
     case .identifier(let syntax, _):
       return syntax.identifier.positionAfterSkippingLeadingTrivia
     case .declaration(let syntax):
-      return syntax.name.position
+      return syntax.name.positionAfterSkippingLeadingTrivia
     case .implicit(let implicitName):
       switch implicitName {
       case .self(let declSyntax):
         switch Syntax(declSyntax).as(SyntaxEnum.self) {
         case .functionDecl(let functionDecl):
-          return functionDecl.name.position
+          return functionDecl.name.positionAfterSkippingLeadingTrivia
         case .initializerDecl(let initializerDecl):
           return initializerDecl.initKeyword.positionAfterSkippingLeadingTrivia
         case .subscriptDecl(let subscriptDecl):
-          return subscriptDecl.accessorBlock?.position ?? subscriptDecl.endPosition
+          return subscriptDecl.accessorBlock?.positionAfterSkippingLeadingTrivia
+            ?? subscriptDecl.endPositionBeforeTrailingTrivia
         case .variableDecl(let variableDecl):
           return variableDecl.bindings.first?.accessorBlock?.positionAfterSkippingLeadingTrivia
             ?? variableDecl.endPosition
         default:
           return declSyntax.positionAfterSkippingLeadingTrivia
         }
-      case .Self(let protocolDecl):
-        return protocolDecl.name.positionAfterSkippingLeadingTrivia
+      case .Self(let declSyntax):
+        switch Syntax(declSyntax).as(SyntaxEnum.self) {
+        case .protocolDecl(let protocolDecl):
+          return protocolDecl.name.positionAfterSkippingLeadingTrivia
+        default:
+          return declSyntax.positionAfterSkippingLeadingTrivia
+        }
       case .error(let catchClause):
-        return catchClause.body.position
+        return catchClause.body.positionAfterSkippingLeadingTrivia
       default:
         return implicitName.syntax.positionAfterSkippingLeadingTrivia
       }

Sources/SwiftLexicalLookup/Scopes/CanInterleaveResultsLaterScopeSyntax.swift

@@ -13,6 +13,9 @@
 import SwiftSyntax
 
 protocol CanInterleaveResultsLaterScopeSyntax: ScopeSyntax {
+  /// Perform lookup in this scope and later introduce results
+  /// passed as `resultsToInterleave`.
+  /// The exact behavior depends on a specific scope.
   func lookupWithInterleavedResults(
     _ identifier: Identifier?,
     at lookUpPosition: AbsolutePosition,

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -498,7 +498,13 @@ import SwiftSyntax
     with config: LookupConfig
   ) -> [LookupResult] {
     if memberBlock.range.contains(lookUpPosition) {
-      return [.lookInMembers(self)] + defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
+      let implicitSelf: [LookupName] = [.implicit(.Self(self))]
+        .filter { name in
+          checkIdentifier(identifier, refersTo: name, at: lookUpPosition)
+        }
+
+      return (implicitSelf.isEmpty ? [] : [.fromScope(self, withNames: implicitSelf)]) + [.lookInMembers(self)]
+        + defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
     } else {
       return defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
     }
@@ -665,13 +671,16 @@ import SwiftSyntax
       )
     }
 
+    let lookInMembers: [LookupResult] =
+      inheritanceClause?.range.contains(lookUpPosition) ?? false ? [] : [.lookInMembers(self)]
+
     return results
       + defaultLookupImplementation(
         identifier,
         at: lookUpPosition,
         with: config,
         propagateToParent: false
-      ) + [.lookInMembers(self)] + lookupInParent(identifier, at: lookUpPosition, with: config)
+      ) + lookInMembers + lookupInParent(identifier, at: lookUpPosition, with: config)
   }
 }
 
@@ -868,12 +877,11 @@ extension SubscriptDeclSyntax: WithGenericParametersScopeSyntax, CanInterleaveRe
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    if let parentScope,
-      parentScope.is(MemberBlockSyntax.self),
-      bindings.first?.accessorBlock?.range.contains(lookUpPosition) ?? false
-    {
+    if bindings.first?.accessorBlock?.range.contains(lookUpPosition) ?? false {
+      let shouldIntroduceSelf = parentScope?.is(MemberBlockSyntax.self) ?? false
+
       return defaultLookupImplementation(
-        in: [.implicit(.self(self))],
+        in: LookupName.getNames(from: self) + (shouldIntroduceSelf ? [.implicit(.self(self))] : []),
         identifier,
         at: lookUpPosition,
         with: config
@@ -883,14 +891,16 @@ extension SubscriptDeclSyntax: WithGenericParametersScopeSyntax, CanInterleaveRe
     }
   }
 
+  /// If a member, introduce results passed in `resultsToInterleave`
+  /// and then pass lookup to the parent. Otherwise, perform `lookup`.
   func lookupWithInterleavedResults(
     _ identifier: Identifier?,
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig,
     resultsToInterleave: [LookupResult]
   ) -> [LookupResult] {
     guard parentScope?.is(MemberBlockSyntax.self) ?? false else {
-      return lookupInParent(identifier, at: lookUpPosition, with: config)
+      return lookup(identifier, at: lookUpPosition, with: config)
     }
 
     return resultsToInterleave + lookupInParent(identifier, at: lookUpPosition, with: config)

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -660,7 +660,7 @@ final class testNameLookup: XCTestCase {
   func testImplicitSelf() {
     assertLexicalNameLookup(
       source: """
-        extension a {
+        7️⃣extension a {
           struct b {
             2️⃣func foo() {
               let x: 3️⃣Self = 4️⃣self
@@ -675,6 +675,7 @@ final class testNameLookup: XCTestCase {
       references: [
         "3️⃣": [
           .lookInMembers(StructDeclSyntax.self),
+          .fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.Self("7️⃣"))]),
           .lookInMembers(ExtensionDeclSyntax.self),
         ],
         "4️⃣": [
@@ -683,7 +684,8 @@ final class testNameLookup: XCTestCase {
           .lookInMembers(ExtensionDeclSyntax.self),
         ],
         "5️⃣": [
-          .lookInMembers(ExtensionDeclSyntax.self)
+          .fromScope(ExtensionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.Self("7️⃣"))]),
+          .lookInMembers(ExtensionDeclSyntax.self),
         ],
         "6️⃣": [
           .fromScope(FunctionDeclSyntax.self, expectedNames: [NameExpectation.implicit(.self("1️⃣"))]),