Add astscope related fixes and lookInMembers functionality.

Author: MAJKFL

Sources/SwiftLexicalLookup/CMakeLists.txt

@@ -17,10 +17,11 @@ add_swift_syntax_library(SwiftLexicalLookup
 
   Scopes/GenericParameterScopeSyntax.swift
   Scopes/IntroducingToSequentialParentScopeSyntax.swift
+  Scopes/LookInMembersScopeSyntax.swift
+  Scopes/NominalTypeDeclSyntax.swift
   Scopes/ScopeImplementations.swift
   Scopes/ScopeSyntax.swift
   Scopes/SequentialScopeSyntax.swift
-  Scopes/TypeScopeSyntax.swift
   Scopes/WithGenericParametersScopeSyntax.swift
 )
 

Sources/SwiftLexicalLookup/Configurations/LookupConfig.swift

@@ -13,14 +13,26 @@
 @_spi(Experimental) public struct LookupConfig {
   /// Specifies behavior of file scope.
   @_spi(Experimental) public var fileScopeHandling: FileScopeHandlingConfig
+  /// Specifies whether lookup should finish in the closest sequential scope.
+  @_spi(Experimental) public var finishInSequentialScope: Bool
+  /// Specifies whether to include results generated in file and member block scopes.
+  @_spi(Experimental) public var includeMembers: Bool
 
   /// Creates a new lookup configuration.
   ///
   /// - `fileScopeHandling` - specifies behavior of file scope.
   ///   `memberBlockUpToLastDecl` by default.
+  /// - `finishInSequentialScope` - specifies whether lookup should finish
+  ///   in the closest sequential scope. `false` by default.
+  /// - `includeMembers` - specifies whether to include results generated
+  ///   in file and member block scopes. `true` by default.
   @_spi(Experimental) public init(
-    fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl
+    fileScopeHandling: FileScopeHandlingConfig = .memberBlockUpToLastDecl,
+    finishInSequentialScope: Bool = false,
+    includeMembers: Bool = true
   ) {
     self.fileScopeHandling = fileScopeHandling
+    self.finishInSequentialScope = finishInSequentialScope
+    self.includeMembers = includeMembers
   }
 }

Sources/SwiftLexicalLookup/LookupName.swift

@@ -16,8 +16,8 @@ import SwiftSyntax
 @_spi(Experimental) public enum ImplicitDecl {
   /// `self` keyword representing object instance.
   /// Could be associated with type declaration, extension,
-  /// or closure captures.
-  case `self`(DeclSyntaxProtocol)
+  /// or closure captures. Introduced at function edge.
+  case `self`(FunctionDeclSyntax)
   /// `Self` keyword representing object type.
   /// Could be associated with type declaration or extension.
   case `Self`(DeclSyntaxProtocol)
@@ -135,6 +135,35 @@ 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
+  /// contain two identifiers) and function declarations (where name
+  /// is precided by access modifiers and `func` keyword).
+  @_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
+      }
+    case .declaration(let syntax):
+      return syntax.name.position
+    case .implicit(let implicitName):
+      switch implicitName {
+      case .self(let functionDecl):
+        return functionDecl.name.position
+      default:
+        return implicitName.syntax.position
+      }
+    }
+  }
+
   /// Point, after which the name is available in scope.
   /// If set to `nil`, the name is available at any point in scope.
   var accessibleAfter: AbsolutePosition? {
@@ -225,4 +254,27 @@ import SwiftSyntax
   ) -> [LookupName] {
     [.declaration(namedDecl)]
   }
+
+  /// Debug description of this lookup name.
+  @_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)"
+
+    switch self {
+    case .identifier:
+      let str = "identifier: \(strName)"
+
+      if let accessibleAfter {
+        let location = sourceLocationConverter.location(for: accessibleAfter)
+        return str + " after: \(location.line):\(location.column)"
+      } else {
+        return str
+      }
+    case .declaration:
+      return "declaration: \(strName)"
+    case .implicit:
+      return "implicit: \(strName)"
+    }
+  }
 }

Sources/SwiftLexicalLookup/LookupResult.swift

@@ -18,14 +18,18 @@ import SwiftSyntax
   case fromScope(ScopeSyntax, withNames: [LookupName])
   /// File scope and names that matched lookup.
   case fromFileScope(SourceFileSyntax, withNames: [LookupName])
+  /// Indicates where to perform member lookup.
+  case lookInMembers(LookInMembersScopeSyntax)
 
   /// Associated scope.
-  @_spi(Experimental) public var scope: ScopeSyntax? {
+  @_spi(Experimental) public var scope: ScopeSyntax {
     switch self {
     case .fromScope(let scopeSyntax, _):
       return scopeSyntax
     case .fromFileScope(let fileScopeSyntax, _):
       return fileScopeSyntax
+    case .lookInMembers(let lookInMemb):
+      return lookInMemb
     }
   }
 
@@ -34,6 +38,8 @@ import SwiftSyntax
     switch self {
     case .fromScope(_, let names), .fromFileScope(_, let names):
       return names
+    case .lookInMembers(_):
+      return []
     }
   }
 
@@ -46,4 +52,54 @@ import SwiftSyntax
       return .fromScope(scope, withNames: names)
     }
   }
+
+  /// Debug description of this lookup name.
+  @_spi(Experimental) public var debugDescription: String {
+    var description =
+      resultKindDebugName + ": " + scope.scopeDebugDescription
+
+    switch self {
+    case .lookInMembers:
+      break
+    default:
+      if !names.isEmpty {
+        description += "\n"
+      }
+    }
+
+    for (index, name) in names.enumerated() {
+      if index + 1 == names.count {
+        description += "`-" + name.debugDescription
+      } else {
+        description += "|-" + name.debugDescription + "\n"
+      }
+    }
+
+    return description
+  }
+
+  /// Debug name of this result kind.
+  private var resultKindDebugName: String {
+    switch self {
+    case .fromScope:
+      return "fromScope"
+    case .fromFileScope:
+      return "fromFileScope"
+    case .lookInMembers:
+      return "lookInMembers"
+    }
+  }
+}
+
+@_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
+  }
 }

Sources/SwiftLexicalLookup/Scopes/GenericParameterScopeSyntax.swift

@@ -16,7 +16,7 @@ import SwiftSyntax
 /// futher lookup to its `WithGenericParametersScopeSyntax`
 /// parent scope's parent scope (i.e. on return, bypasses names
 /// introduced by its parent).
-@_spi(Experimental) public protocol GenericParameterScopeSyntax: ScopeSyntax {}
+protocol GenericParameterScopeSyntax: ScopeSyntax {}
 
 @_spi(Experimental) extension GenericParameterScopeSyntax {
   /// Returns names matching lookup and bypasses
@@ -83,7 +83,7 @@ import SwiftSyntax
     if let parentScope = Syntax(parentScope).asProtocol(SyntaxProtocol.self)
       as? WithGenericParametersScopeSyntax
     {
-      return parentScope.lookupInParent(identifier, at: lookUpPosition, with: config)
+      return parentScope.returningLookupFromGenericParameterScope(identifier, at: lookUpPosition, with: config)
     } else {
       return lookupInParent(identifier, at: lookUpPosition, with: config)
     }

Sources/SwiftLexicalLookup/Scopes/TypeScopeSyntax.swift renamed to Sources/SwiftLexicalLookup/Scopes/LookInMembersScopeSyntax.swift

@@ -12,14 +12,7 @@
 
 import SwiftSyntax
 
-@_spi(Experimental) public protocol TypeScopeSyntax: ScopeSyntax, DeclSyntaxProtocol {}
-
-extension TypeScopeSyntax {
-  @_spi(Experimental) public var implicitInstanceAndTypeNames: [LookupName] {
-    [.implicit(.self(self)), .implicit(.Self(self))]
-  }
-
-  @_spi(Experimental) public var introducedNames: [LookupName] {
-    implicitInstanceAndTypeNames
-  }
+@_spi(Experimental) public protocol LookInMembersScopeSyntax: ScopeSyntax {
+  /// Position used for member lookup.
+  var lookupMembersPosition: AbsolutePosition { get }
 }

Sources/SwiftLexicalLookup/Scopes/NominalTypeDeclSyntax.swift

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 NominalTypeDeclSyntax: LookInMembersScopeSyntax, NamedDeclSyntax, WithGenericParametersScopeSyntax {
+  var inheritanceClause: InheritanceClauseSyntax? { get }
+}
+
+extension NominalTypeDeclSyntax {
+  @_spi(Experimental) public var lookupMembersPosition: AbsolutePosition {
+    name.position
+  }
+
+  /// Nominal type doesn't introduce any names by itself.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    []
+  }
+
+  /// Function used by generic parameter clause
+  /// scope on return from it's lookup.
+  func returningLookupFromGenericParameterScope(
+    _ identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    if let inheritanceClause, inheritanceClause.range.contains(lookUpPosition) {
+      return lookupInParent(identifier, at: lookUpPosition, with: config)
+    } else {
+      return [.lookInMembers(self)] + lookupInParent(identifier, at: lookUpPosition, with: config)
+    }
+  }
+}