Add suggested changes. Add new specialized scope: CanInterleaveResultsLaterScopeSyntax.

Author: MAJKFL

Sources/SwiftLexicalLookup/CMakeLists.txt

@@ -15,6 +15,7 @@ add_swift_syntax_library(SwiftLexicalLookup
   Configurations/FileScopeHandlingConfig.swift
   Configurations/LookupConfig.swift
 
+  Scopes/CanInterleaveResultsLaterScopeSyntax.swift
   Scopes/FunctionScopeSyntax.swift
   Scopes/GenericParameterScopeSyntax.swift
   Scopes/IntroducingToSequentialParentScopeSyntax.swift

Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -14,8 +14,43 @@
   /// Specifies behavior of file scope.
   @_spi(Experimental) public var fileScopeHandling: FileScopeHandlingConfig
   /// Specifies whether lookup should finish in the closest sequential scope.
+  ///
+  /// ### Example
+  /// ```swift
+  /// class X {
+  ///   let a = 42
+  ///
+  ///   func (a: Int) {
+  ///     let a = 123
+  ///
+  ///     a // <-- lookup here
+  ///   }
+  /// }
+  /// ```
+  /// When looking up at the specified position with `finishInSequentialScope`
+  /// set to `false`, lookup will return declaration from inside function body,
+  /// function parameter and the `a` declaration from `class X` member block.
+  /// If `finishInSequentialScope` would be set to `false`, the only name
+  /// returned by lookup would be the `a` declaration from inside function body.
   @_spi(Experimental) public var finishInSequentialScope: Bool
   /// Specifies whether to include results generated in file and member block scopes.
+  ///
+  /// ### Example
+  /// ```swift
+  /// class X {
+  ///   let a = 42
+  ///
+  ///   func (a: Int) {
+  ///     let a = 123
+  ///
+  ///     a // <-- lookup here
+  ///   }
+  /// }
+  /// ```
+  /// When looking up at the specified position with `includeMembers`
+  /// set to `true`, lookup will return declaration from inside function body,
+  /// function parameter and the `a` declaration from `class X` member block.
+  /// If `includeMembers` would be set to `false`, the latter name would be omitted.
   @_spi(Experimental) public var includeMembers: Bool
 
   /// Creates a new lookup configuration.

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`(DeclSyntaxProtocol)
+  case `Self`(ProtocolDeclSyntax)
   /// `error` value caught by a `catch`
   /// block that does not specify a catch pattern.
   case error(CatchClauseSyntax)
@@ -164,13 +164,8 @@ import SwiftSyntax
         default:
           return declSyntax.positionAfterSkippingLeadingTrivia
         }
-      case .Self(let declSyntax):
-        switch Syntax(declSyntax).as(SyntaxEnum.self) {
-        case .protocolDecl(let protocolDecl):
-          return protocolDecl.name.positionAfterSkippingLeadingTrivia
-        default:
-          return declSyntax.positionAfterSkippingLeadingTrivia
-        }
+      case .Self(let protocolDecl):
+        return protocolDecl.name.positionAfterSkippingLeadingTrivia
       case .error(let catchClause):
         return catchClause.body.position
       default:
@@ -271,7 +266,7 @@ import SwiftSyntax
   @_spi(Experimental) public var debugDescription: String {
     let sourceLocationConverter = SourceLocationConverter(fileName: "", tree: syntax.root)
     let location = sourceLocationConverter.location(for: position)
-    let strName = (identifier != nil ? identifier!.name : "NO-NAME") + " at: \(location.line):\(location.column)"
+    let strName = (identifier?.name ?? "NO-NAME") + " at: \(location.line):\(location.column)"
 
     switch self {
     case .identifier:

Sources/SwiftLexicalLookup/LookupResult.swift

@@ -94,12 +94,6 @@ import SwiftSyntax
 @_spi(Experimental) extension [LookupResult] {
   /// Debug description this array of lookup results.
   @_spi(Experimental) public var debugDescription: String {
-    var str: String = ""
-
-    for (index, result) in self.enumerated() {
-      str += result.debugDescription + (index + 1 == self.count ? "" : "\n")
-    }
-
-    return str
+    return self.map(\.debugDescription).joined(separator: "\n")
   }
 }

Sources/SwiftLexicalLookup/Scopes/CanInterleaveResultsLaterScopeSyntax.swift

@@ -0,0 +1,22 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 CanInterleaveResultsLaterScopeSyntax: ScopeSyntax {
+  func lookupWithInterleavedResults(
+    _ identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig,
+    resultsToInterleave: [LookupResult]
+  ) -> [LookupResult]
+}

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -508,22 +508,18 @@ 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 {
-      names = LookupName.getNames(from: parameters)
+      return LookupName.getNames(from: parameters)
     } else {
       switch accessorSpecifier.tokenKind {
       case .keyword(.set), .keyword(.willSet):
-        names = [.implicit(.newValue(self))]
+        return [.implicit(.newValue(self))]
       case .keyword(.didSet):
-        names = [.implicit(.oldValue(self))]
+        return [.implicit(.oldValue(self))]
       default:
-        names = []
+        return []
       }
     }
-
-    return names
   }
 
   @_spi(Experimental) public var scopeDebugName: String {
@@ -539,7 +535,10 @@ import SwiftSyntax
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    guard let parentAccessorBlockScope = parentScope?.as(AccessorBlockSyntax.self) else {
+    guard let parentScope,
+      let canInterleaveLaterScope = Syntax(parentScope).asProtocol(SyntaxProtocol.self)
+        as? CanInterleaveResultsLaterScopeSyntax
+    else {
       return defaultLookupImplementation(identifier, at: lookUpPosition, with: config)
     }
 
@@ -554,7 +553,7 @@ import SwiftSyntax
       with: config,
       propagateToParent: false
     )
-      + parentAccessorBlockScope.interleaveAccessorResultsAfterSubscriptLookup(
+      + canInterleaveLaterScope.lookupWithInterleavedResults(
         identifier,
         at: lookUpPosition,
         with: config,
@@ -701,7 +700,8 @@ import SwiftSyntax
   }
 }
 
-@_spi(Experimental) extension SubscriptDeclSyntax: WithGenericParametersScopeSyntax {
+@_spi(Experimental)
+extension SubscriptDeclSyntax: WithGenericParametersScopeSyntax, CanInterleaveResultsLaterScopeSyntax {
   /// Parameters introduced by this subscript and possibly `self` keyword.
   @_spi(Experimental) public var introducedNames: [LookupName] {
     let parameters = parameterClause.parameters.flatMap { parameter in
@@ -726,7 +726,7 @@ import SwiftSyntax
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    interleaveResultsAfterThisSubscriptLookup(
+    lookupWithInterleavedResults(
       identifier,
       at: lookUpPosition,
       with: config,
@@ -753,7 +753,7 @@ import SwiftSyntax
   /// introduced at the boundary of the getter. That's why
   /// this function needs to ensure the implicit `self` passed
   /// from inside the accessor block is added after `subscript` parameters.
-  func interleaveResultsAfterThisSubscriptLookup(
+  func lookupWithInterleavedResults(
     _ identifier: Identifier?,
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig,
@@ -779,7 +779,7 @@ import SwiftSyntax
   }
 }
 
-@_spi(Experimental) extension AccessorBlockSyntax: SequentialScopeSyntax {
+@_spi(Experimental) extension AccessorBlockSyntax: SequentialScopeSyntax, CanInterleaveResultsLaterScopeSyntax {
   /// Names from the accessors or
   /// getters of this accessor block scope.
   @_spi(Experimental) public var introducedNames: [LookupName] {
@@ -815,17 +815,20 @@ import SwiftSyntax
 
   /// Used by children accessors to interleave
   /// their results with parent `subscript` declaration scope.
-  func interleaveAccessorResultsAfterSubscriptLookup(
+  func lookupWithInterleavedResults(
     _ identifier: Identifier?,
     at lookUpPosition: AbsolutePosition,
     with config: LookupConfig,
     resultsToInterleave: [LookupResult]
   ) -> [LookupResult] {
-    guard let parentSubscriptScope = parentScope?.as(SubscriptDeclSyntax.self) else {
+    guard let parentScope,
+      let canInterleaveLaterScope = Syntax(parentScope).asProtocol(SyntaxProtocol.self)
+        as? CanInterleaveResultsLaterScopeSyntax
+    else {
       return lookupInParent(identifier, at: lookUpPosition, with: config)
     }
 
-    return parentSubscriptScope.interleaveResultsAfterThisSubscriptLookup(
+    return canInterleaveLaterScope.lookupWithInterleavedResults(
       identifier,
       at: lookUpPosition,
       with: config,
@@ -845,7 +848,7 @@ import SwiftSyntax
   }
 }
 
-@_spi(Experimental) extension VariableDeclSyntax: ScopeSyntax {
+@_spi(Experimental) extension VariableDeclSyntax: CanInterleaveResultsLaterScopeSyntax {
   /// Variable decl scope doesn't introduce any
   /// names unless it is a member and is looked
   /// up from inside it's accessor block.
@@ -879,4 +882,17 @@ import SwiftSyntax
       return lookupInParent(identifier, at: lookUpPosition, with: config)
     }
   }
+
+  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 resultsToInterleave + lookupInParent(identifier, at: lookUpPosition, with: config)
+  }
 }