Merge pull request #2852 from MAJKFL/astscope-fixes-generics-lookmembers

[SwiftLexicalLookup] Add ASTScope related fixes and lookInMembers result kind.

Author: MAJKFL

Sources/SwiftLexicalLookup/CMakeLists.txt

@@ -15,12 +15,15 @@ add_swift_syntax_library(SwiftLexicalLookup
   Configurations/FileScopeHandlingConfig.swift
   Configurations/LookupConfig.swift
 
+  Scopes/CanInterleaveResultsLaterScopeSyntax.swift
+  Scopes/FunctionScopeSyntax.swift
   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,61 @@
 @_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.
+  ///
+  /// ### 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.
   ///
   /// - `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,7 +16,7 @@ import SwiftSyntax
 @_spi(Experimental) public enum ImplicitDecl {
   /// `self` keyword representing object instance.
   /// Could be associated with type declaration, extension,
-  /// or closure captures.
+  /// or closure captures. Introduced at function edge.
   case `self`(DeclSyntaxProtocol)
   /// `Self` keyword representing object type.
   /// Could be associated with type declaration or extension.
@@ -135,6 +135,51 @@ 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, _):
+      return syntax.identifier.positionAfterSkippingLeadingTrivia
+    case .declaration(let syntax):
+      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.positionAfterSkippingLeadingTrivia
+        case .initializerDecl(let initializerDecl):
+          return initializerDecl.initKeyword.positionAfterSkippingLeadingTrivia
+        case .subscriptDecl(let subscriptDecl):
+          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 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.positionAfterSkippingLeadingTrivia
+      default:
+        return implicitName.syntax.positionAfterSkippingLeadingTrivia
+      }
+    }
+  }
+
   /// 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? {
@@ -166,7 +211,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
@@ -194,6 +239,8 @@ import SwiftSyntax
       return functionCallExpr.arguments.flatMap { argument in
         getNames(from: argument.expression, accessibleAfter: accessibleAfter)
       }
+    case .optionalChainingExpr(let optionalChainingExpr):
+      return getNames(from: optionalChainingExpr.expression, accessibleAfter: accessibleAfter)
     default:
       if let namedDecl = Syntax(syntax).asProtocol(SyntaxProtocol.self) as? NamedDeclSyntax {
         return handle(namedDecl: namedDecl, accessibleAfter: accessibleAfter)
@@ -210,12 +257,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.
@@ -225,4 +267,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?.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,48 @@ 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 {
+    return self.map(\.debugDescription).joined(separator: "\n")
+  }
 }

Sources/SwiftLexicalLookup/Scopes/CanInterleaveResultsLaterScopeSyntax.swift

@@ -0,0 +1,25 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 {
+  /// 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,
+    with config: LookupConfig,
+    resultsToInterleave: [LookupResult]
+  ) -> [LookupResult]
+}

Sources/SwiftLexicalLookup/Scopes/FunctionScopeSyntax.swift

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 FunctionScopeSyntax: DeclSyntaxProtocol, WithGenericParametersScopeSyntax {
+  var signature: FunctionSignatureSyntax { get }
+}
+
+extension FunctionScopeSyntax {
+  /// Function parameters introduced by this function's signature.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    signature.parameterClause.parameters.flatMap { parameter in
+      LookupName.getNames(from: parameter)
+    } + (parentScope?.is(MemberBlockSyntax.self) ?? false ? [.implicit(.self(self))] : [])
+  }
+
+  /// Lookup results from this function 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 !signature.range.contains(lookUpPosition) {
+      thisScopeResults = defaultLookupImplementation(
+        identifier,
+        at: position,
+        with: config,
+        propagateToParent: false
+      )
+    }
+
+    return thisScopeResults
+      + lookupThroughGenericParameterScope(
+        identifier,
+        at: lookUpPosition,
+        with: config
+      )
+  }
+}

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 }
 }