Add switch, generic parameter and function scopes.

Author: MAJKFL

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -25,6 +25,12 @@ import SwiftSyntax
   }
 }
 
+@_spi(Experimental) extension FunctionParameterSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: TokenSyntax {
+    secondName ?? firstName
+  }
+}
+
 @_spi(Experimental) extension ClosureShorthandParameterSyntax: IdentifiableSyntax {
   @_spi(Experimental) public var identifier: TokenSyntax {
     name
@@ -47,3 +53,15 @@ import SwiftSyntax
     name
   }
 }
+
+@_spi(Experimental) extension GenericParameterSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: TokenSyntax {
+    name
+  }
+}
+
+@_spi(Experimental) extension PrimaryAssociatedTypeSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: TokenSyntax {
+    name
+  }
+}

Sources/SwiftLexicalLookup/LookupName.swift

@@ -110,10 +110,6 @@ import SwiftSyntax
   case declaration(NamedDeclSyntax)
   /// Name introduced implicitly by certain syntax nodes.
   case implicit(ImplicitDecl)
-  /// Explicit `self` keyword.
-  case `self`(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
-  /// Explicit `Self` keyword.
-  case `Self`(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
@@ -124,8 +120,6 @@ import SwiftSyntax
       return syntax
     case .implicit(let implicitName):
       return implicitName.syntax
-    case .self(let syntax, _), .Self(let syntax, _):
-      return syntax
     }
   }
 
@@ -138,35 +132,28 @@ import SwiftSyntax
       return Identifier(syntax.name)
     case .implicit(let kind):
       return kind.identifier
-    case .self:
-      return Identifier("self")
-    case .Self:
-      return Identifier("Self")
     }
   }
 
   /// 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? {
     switch self {
-    case .identifier(_, let absolutePosition),
-      .self(_, let absolutePosition),
-      .Self(_, let absolutePosition):
+    case .identifier(_, let absolutePosition):
       return absolutePosition
     default:
       return nil
     }
   }
 
   /// Checks if this name was introduced before the syntax used for lookup.
-  func isAccessible(at origin: AbsolutePosition) -> Bool {
+  func isAccessible(at lookUpPosition: AbsolutePosition) -> Bool {
     guard let accessibleAfter else { return true }
-    return accessibleAfter <= origin
+    return accessibleAfter <= lookUpPosition
   }
 
   /// Checks if this name refers to the looked up phrase.
   func refersTo(_ lookedUpIdentifier: Identifier) -> Bool {
-    guard let identifier else { return false }
     return identifier == lookedUpIdentifier
   }
 
@@ -229,16 +216,10 @@ import SwiftSyntax
     accessibleAfter: AbsolutePosition? = nil
   ) -> [LookupName] {
     switch identifiable.identifier.tokenKind {
-    case .keyword(.self):
-      return [.self(identifiable, accessibleAfter: accessibleAfter)]
-    case .keyword(.Self):
-      return [.Self(identifiable, accessibleAfter: accessibleAfter)]
+    case .wildcard:
+      return []
     default:
-      if identifiable.identifier.tokenKind != .wildcard {
-        return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
-      } else {
-        return []
-      }
+      return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     }
   }
 

Sources/SwiftLexicalLookup/Scopes/GenericParameterOrAssociatedTypeScopeSyntax.swift

@@ -0,0 +1,92 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+/// Scope that introduces generic parameter or
+/// primary associated type names and directs
+/// futher lookup to it's `WithGenericParametersOrAssociatedTypesScopeSyntax`
+/// parent scope's parent scope (i.e. on return, bypasses names
+/// introduced by it's parent).
+@_spi(Experimental) public protocol GenericParameterOrAssociatedTypeScopeSyntax: ScopeSyntax {}
+
+@_spi(Experimental) extension GenericParameterOrAssociatedTypeScopeSyntax {
+  /// Returns names matching lookup and bypasses
+  /// `WithGenericParametersOrAssociatedTypesScopeSyntax` parent scope in futher lookup.
+  ///
+  /// example:
+  /// ```swift
+  /// let a = 23
+  /// func foo<A>(a: A) {
+  ///   a // <-- start lookup here
+  /// }
+  /// ```
+  /// When starting lookup at the `a` reference,
+  /// lookup first visits the code block scope associated
+  /// with the function's body. Then, it's forwarded to the
+  /// function declaration scope and then to generic parameter
+  /// scope (`WithGenericParametersOrAssociatedTypesScopeSyntax`).
+  /// Then, to ensure there is no infinite cycle,
+  /// this method passes lookup to function scope's parent scope
+  /// (in this case: file scope).
+  @_spi(Experimental) public func lookup(
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    return defaultLookupImplementation(
+      identifier: identifier,
+      at: lookUpPosition,
+      with: config,
+      propagateToParent: false
+    )
+      + lookupBypassingParentResults(
+        identifier: identifier,
+        at: lookUpPosition,
+        with: config
+      )
+  }
+
+  /// Bypasses names introduced by `WithGenericParametersOrAssociatedTypesScopeSyntax` parent scope.
+  ///
+  /// example:
+  /// ```swift
+  /// let a = 23
+  /// func foo<A>(a: A) {
+  ///   a // <-- start lookup here
+  /// }
+  /// ```
+  /// When starting lookup at the `a` reference,
+  /// lookup first visits the code block scope associated
+  /// with the function's body. Then, it's forwarded to the
+  /// function declaration scope and then to generic parameter
+  /// scope (`WithGenericParametersOrAssociatedTypesScopeSyntax`).
+  /// Then, to ensure there is no infinite cycle,
+  /// we use this method instead of the standard `lookupInParent`
+  /// to pass lookup to the function scope's parent scope (in this case: file scope)
+  /// and effectively bypass names already looked up before.
+  private func lookupBypassingParentResults(
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
+    with config: LookupConfig
+  ) -> [LookupResult] {
+    guard let parentScope else { return [] }
+
+    if let parentScope = Syntax(parentScope).asProtocol(SyntaxProtocol.self)
+      as? WithGenericParametersOrAssociatedTypesScopeSyntax
+    {
+      return parentScope.lookupInParent(identifier: identifier, at: lookUpPosition, with: config)
+    } else {
+      return lookupInParent(identifier: identifier, at: lookUpPosition, with: config)
+    }
+  }
+}

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift renamed to Sources/SwiftLexicalLookup/Scopes/IntroducingToSequentialParentScopeSyntax.swift

@@ -19,8 +19,8 @@ protocol IntroducingToSequentialParentScopeSyntax: ScopeSyntax {
   /// Returns results matching lookup that should be
   /// interleaved with results of the sequential parent.
   func lookupFromSequentialParent(
-    for identifier: Identifier?,
-    at origin: AbsolutePosition,
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult]
 }

Sources/SwiftLexicalLookup/ScopeImplementations.swift renamed to Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -97,15 +97,15 @@ import SwiftSyntax
   /// - for `memberBlock` - a, b, c, d, e, f
   /// - for `codeBlock` - a
   @_spi(Experimental) public func lookup(
-    for identifier: Identifier?,
-    at origin: AbsolutePosition,
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
     switch config.fileScopeHandling {
     case .memberBlock:
       let names = introducedNames(using: .memberBlock)
         .filter { lookupName in
-          checkName(identifier, refersTo: lookupName, at: origin)
+          checkName(identifier, refersTo: lookupName, at: lookUpPosition)
         }
 
       return names.isEmpty ? [] : [.fromFileScope(self, withNames: names)]
@@ -119,22 +119,19 @@ import SwiftSyntax
 
         if encounteredNonDeclaration {
           sequentialItems.append(codeBlockItem)
+        } else if item.is(DeclSyntax.self) {
+          let foundNames = LookupName.getNames(from: item)
+          members.append(contentsOf: foundNames.filter { checkName(identifier, refersTo: $0, at: lookUpPosition) })
         } else {
-          if item.is(DeclSyntax.self) {
-            let foundNames = LookupName.getNames(from: item)
-
-            members.append(contentsOf: foundNames.filter { checkName(identifier, refersTo: $0, at: origin) })
-          } else {
-            encounteredNonDeclaration = true
-            sequentialItems.append(codeBlockItem)
-          }
+          encounteredNonDeclaration = true
+          sequentialItems.append(codeBlockItem)
         }
       }
 
       let sequentialNames = sequentialLookup(
         in: sequentialItems,
-        for: identifier,
-        at: origin,
+        identifier: identifier,
+        at: lookUpPosition,
         with: config,
         createResultsForThisScopeWith: { .fromFileScope(self, withNames: $0) }
       )
@@ -154,14 +151,14 @@ import SwiftSyntax
   }
 
   @_spi(Experimental) public func lookup(
-    for identifier: Identifier?,
-    at origin: AbsolutePosition,
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
     sequentialLookup(
       in: statements,
-      for: identifier,
-      at: origin,
+      identifier: identifier,
+      at: lookUpPosition,
       with: config,
       createResultsForThisScopeWith: { .fromScope(self, withNames: $0) }
     )
@@ -274,14 +271,14 @@ import SwiftSyntax
   /// }
   /// ```
   @_spi(Experimental) public func lookup(
-    for identifier: Identifier?,
-    at origin: AbsolutePosition,
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    if let elseBody, elseBody.position <= origin, elseBody.endPosition >= origin {
-      return lookupInParent(for: identifier, at: origin, with: config)
+    if let elseBody, elseBody.range.contains(lookUpPosition) {
+      return lookupInParent(identifier: identifier, at: lookUpPosition, with: config)
     } else {
-      return defaultLookupImplementation(for: identifier, at: origin, with: config)
+      return defaultLookupImplementation(identifier: identifier, at: lookUpPosition, with: config)
     }
   }
 }
@@ -319,25 +316,24 @@ import SwiftSyntax
   /// // a is visible here
   /// ```
   func lookupFromSequentialParent(
-    for identifier: Identifier?,
-    at origin: AbsolutePosition,
+    identifier: Identifier?,
+    at lookUpPosition: AbsolutePosition,
     with config: LookupConfig
   ) -> [LookupResult] {
-    guard body.position > origin || body.endPosition < origin
-    else { return [] }
+    guard !body.range.contains(lookUpPosition) else { return [] }
 
     let names = namesIntroducedToSequentialParent.filter { introducedName in
-      checkName(identifier, refersTo: introducedName, at: origin)
+      checkName(identifier, refersTo: introducedName, at: lookUpPosition)
     }
 
     return names.isEmpty ? [] : [.fromScope(self, withNames: names)]
   }
 }
 
-@_spi(Experimental) extension ActorDeclSyntax: TypeScopeSyntax {}
-@_spi(Experimental) extension ClassDeclSyntax: TypeScopeSyntax {}
-@_spi(Experimental) extension StructDeclSyntax: TypeScopeSyntax {}
-@_spi(Experimental) extension EnumDeclSyntax: TypeScopeSyntax {}
+@_spi(Experimental) extension ActorDeclSyntax: TypeScopeSyntax, WithGenericParametersOrAssociatedTypesScopeSyntax {}
+@_spi(Experimental) extension ClassDeclSyntax: TypeScopeSyntax, WithGenericParametersOrAssociatedTypesScopeSyntax {}
+@_spi(Experimental) extension StructDeclSyntax: TypeScopeSyntax, WithGenericParametersOrAssociatedTypesScopeSyntax {}
+@_spi(Experimental) extension EnumDeclSyntax: TypeScopeSyntax, WithGenericParametersOrAssociatedTypesScopeSyntax {}
 @_spi(Experimental) extension ExtensionDeclSyntax: TypeScopeSyntax {}
 
 @_spi(Experimental) extension AccessorDeclSyntax: ScopeSyntax {
@@ -360,7 +356,50 @@ import SwiftSyntax
 
 @_spi(Experimental) extension CatchClauseSyntax: ScopeSyntax {
   /// Implicit `error` when there are no catch items.
-  public var introducedNames: [LookupName] {
+  @_spi(Experimental) public var introducedNames: [LookupName] {
     return catchItems.isEmpty ? [.implicit(.error(self))] : []
   }
 }
+
+@_spi(Experimental) extension SwitchCaseSyntax: ScopeSyntax {
+  /// Names introduced within `case` items.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    label.as(SwitchCaseLabelSyntax.self)?.caseItems.flatMap { child in
+      LookupName.getNames(from: child.pattern)
+    } ?? []
+  }
+}
+
+@_spi(Experimental) extension GenericParameterClauseSyntax: GenericParameterOrAssociatedTypeScopeSyntax {
+  /// Generic parameter names introduced by this clause.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    parameters.children(viewMode: .sourceAccurate).flatMap { child in
+      LookupName.getNames(from: child, accessibleAfter: child.endPosition)
+    }
+  }
+}
+
+@_spi(Experimental) extension PrimaryAssociatedTypeClauseSyntax: GenericParameterOrAssociatedTypeScopeSyntax {
+  /// Primary associated type names introduced by this clause.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    primaryAssociatedTypes.children(viewMode: .sourceAccurate).flatMap { child in
+      LookupName.getNames(from: child, accessibleAfter: child.endPosition)
+    }
+  }
+}
+
+@_spi(Experimental) extension ProtocolDeclSyntax: WithGenericParametersOrAssociatedTypesScopeSyntax {
+  /// Protocol declarations don't introduce names by themselves.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    []
+  }
+}
+
+@_spi(Experimental) extension FunctionDeclSyntax: WithGenericParametersOrAssociatedTypesScopeSyntax {
+  /// Function parameters introduced by this function's signature.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    signature.parameterClause.parameters.flatMap { parameter in
+      LookupName.getNames(from: parameter)
+    }
+  }
+}