Move name accessibility evaluation to LookupName. Simplify name extraction in LookupName.

Author: MAJKFL

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//
+// 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
+
+/// Syntax node that can be refered to with an identifier.
+public protocol IdentifiableSyntax: SyntaxProtocol {
+  var identifier: TokenSyntax { get }
+}
+
+extension IdentifierPatternSyntax: IdentifiableSyntax {}
+
+extension ClosureParameterSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: SwiftSyntax.TokenSyntax {
+    secondName ?? firstName
+  }
+}
+
+extension ClosureShorthandParameterSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: SwiftSyntax.TokenSyntax {
+    name
+  }
+}

Sources/SwiftLexicalLookup/LookupName.swift

@@ -15,34 +15,46 @@ import SwiftSyntax
 @_spi(Experimental) public enum LookupName {
   /// Identifier associated with the name.
   /// Could be an identifier of a variable, function or closure parameter and more
-  case identifier(String, SyntaxProtocol)
+  case identifier(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
   /// Declaration associated with the name.
   /// Could be class, struct, actor, protocol, function and more
-  case declaration(String, DeclSyntaxProtocol)
+  case declaration(NamedDeclSyntax, accessibleAfter: AbsolutePosition?)
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
     switch self {
-    case .identifier(_, let syntax):
+    case .identifier(let syntax, _):
       syntax
-    case .declaration(_, let syntax):
+    case .declaration(let syntax, _):
       syntax
     }
   }
 
   /// Introduced name.
   @_spi(Experimental) public var name: String {
     switch self {
-    case .identifier(let name, _):
-      name
-    case .declaration(let name, _):
-      name
+    case .identifier(let syntax, _):
+      syntax.identifier.text
+    case .declaration(let syntax, _):
+      syntax.name.text
+    }
+  }
+  
+  /// 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):
+      absolutePosition
+    case .declaration(_, let absolutePosition):
+      absolutePosition
     }
   }
 
   /// Checks if this name was introduced before the syntax used for lookup.
-  func isBefore(_ lookedUpSyntax: SyntaxProtocol) -> Bool {
-    syntax.position < lookedUpSyntax.position
+  func isAccessible(at lookedUpSyntax: SyntaxProtocol) -> Bool {
+    guard let accessibleAfter else { return true }
+    return accessibleAfter <= lookedUpSyntax.position
   }
 
   /// Checks if this name refers to the looked up phrase.
@@ -51,91 +63,50 @@ import SwiftSyntax
   }
 
   /// Extracts names introduced by the given `from` structure.
-  static func getNames(from syntax: SyntaxProtocol) -> [LookupName] {
+  static func getNames(from syntax: SyntaxProtocol, accessibleAfter: AbsolutePosition? = nil) -> [LookupName] {
     switch Syntax(syntax).as(SyntaxEnum.self) {
     case .variableDecl(let variableDecl):
       variableDecl.bindings.flatMap { binding in
-        getNames(from: binding.pattern)
+        getNames(from: binding.pattern, accessibleAfter: accessibleAfter)
       }
     case .tuplePattern(let tuplePattern):
       tuplePattern.elements.flatMap { tupleElement in
-        getNames(from: tupleElement.pattern)
+        getNames(from: tupleElement.pattern, accessibleAfter: accessibleAfter)
       }
     case .valueBindingPattern(let valueBindingPattern):
-      getNames(from: valueBindingPattern.pattern)
+      getNames(from: valueBindingPattern.pattern, accessibleAfter: accessibleAfter)
     case .expressionPattern(let expressionPattern):
-      getNames(from: expressionPattern.expression)
+      getNames(from: expressionPattern.expression, accessibleAfter: accessibleAfter)
     case .sequenceExpr(let sequenceExpr):
       sequenceExpr.elements.flatMap { expression in
-        getNames(from: expression)
+        getNames(from: expression, accessibleAfter: accessibleAfter)
       }
     case .patternExpr(let patternExpr):
-      getNames(from: patternExpr.pattern)
+      getNames(from: patternExpr.pattern, accessibleAfter: accessibleAfter)
     case .optionalBindingCondition(let optionalBinding):
-      getNames(from: optionalBinding.pattern)
-    case .identifierPattern(let identifierPattern):
-      handle(identifierPattern: identifierPattern)
-    case .closureShorthandParameter(let closureShorthandParameter):
-      handle(closureShorthandParameter: closureShorthandParameter)
-    case .closureParameter(let closureParameter):
-      handle(closureParameter: closureParameter)
-    case .functionDecl(let functionDecl):
-      handle(functionDecl: functionDecl)
-    case .classDecl(let classDecl):
-      handle(classDecl: classDecl)
-    case .structDecl(let structDecl):
-      handle(structDecl: structDecl)
-    case .actorDecl(let actorDecl):
-      handle(actorDecl: actorDecl)
-    case .protocolDecl(let protocolDecl):
-      handle(protocolDecl: protocolDecl)
+      getNames(from: optionalBinding.pattern, accessibleAfter: accessibleAfter)
     default:
-      []
+      if let namedDecl = Syntax(syntax).asProtocol(SyntaxProtocol.self) as? NamedDeclSyntax {
+        handle(namedDecl: namedDecl, accessibleAfter: accessibleAfter)
+      } else if let identifiable = Syntax(syntax).asProtocol(SyntaxProtocol.self) as? IdentifiableSyntax {
+        handle(identifiable: identifiable, accessibleAfter: accessibleAfter)
+      } else {
+        []
+      }
     }
   }
 
-  /// Extracts name introduced by `identifierPattern`.
-  private static func handle(identifierPattern: IdentifierPatternSyntax) -> [LookupName] {
-    [.identifier(identifierPattern.identifier.text, identifierPattern)]
-  }
-
-  /// Extracts name introduced by `closureParameter`.
-  private static func handle(closureParameter: ClosureParameterSyntax) -> [LookupName] {
-    [.identifier(closureParameter.secondName?.text ?? closureParameter.firstName.text, closureParameter)]
-  }
-
-  /// Extracts name introduced by `closureShorthandParameter`.
-  private static func handle(closureShorthandParameter: ClosureShorthandParameterSyntax) -> [LookupName] {
-    let name = closureShorthandParameter.name.text
-    if name != "_" {
-      return [.identifier(name, closureShorthandParameter)]
+  /// Extracts name introduced by `IdentifiableSyntax` node.
+  private static func handle(identifiable: IdentifiableSyntax, accessibleAfter: AbsolutePosition? = nil) -> [LookupName] {
+    if identifiable.identifier.text != "_" {
+      return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     } else {
       return []
     }
   }
-
-  /// Extracts name introduced by `functionDecl`.
-  private static func handle(functionDecl: FunctionDeclSyntax) -> [LookupName] {
-    [.declaration(functionDecl.name.text, functionDecl)]
-  }
-
-  /// Extracts name introduced by `classDecl`.
-  private static func handle(classDecl: ClassDeclSyntax) -> [LookupName] {
-    [.declaration(classDecl.name.text, classDecl)]
-  }
-
-  /// Extracts name introduced by `structDecl`.
-  private static func handle(structDecl: StructDeclSyntax) -> [LookupName] {
-    [.declaration(structDecl.name.text, structDecl)]
-  }
-
-  /// Extracts name introduced by `actorDecl`.
-  private static func handle(actorDecl: ActorDeclSyntax) -> [LookupName] {
-    [.declaration(actorDecl.name.text, actorDecl)]
-  }
-
-  /// Extracts name introduced by `protocolDecl`.
-  private static func handle(protocolDecl: ProtocolDeclSyntax) -> [LookupName] {
-    [.declaration(protocolDecl.name.text, protocolDecl)]
+  
+  /// Extracts name introduced by `NamedDeclSyntax` node.
+  private static func handle(namedDecl: NamedDeclSyntax, accessibleAfter: AbsolutePosition? = nil) -> [LookupName] {
+    [.declaration(namedDecl, accessibleAfter: accessibleAfter)]
   }
 }

Sources/SwiftLexicalLookup/ScopeImplementations.swift

@@ -15,61 +15,32 @@ import SwiftSyntax
 extension SyntaxProtocol {
   /// Parent scope of this syntax node, or scope introduced by this syntax node.
   var scope: ScopeSyntax? {
-    switch Syntax(self).as(SyntaxEnum.self) {
-    case .sourceFile(let sourceFile):
-      sourceFile
-    case .codeBlock(let codeBlock):
-      codeBlock
-    case .forStmt(let forStmt):
-      forStmt
-    case .closureExpr(let closureExpr):
-      closureExpr
-    case .whileStmt(let whileStmt):
-      whileStmt
-    case .ifExpr(let ifExpr):
-      ifExpr
-    case .memberBlock(let memberBlock):
-      memberBlock
-    default:
+    if let scopeSyntax = Syntax(self).asProtocol(SyntaxProtocol.self) as? ScopeSyntax {
+      scopeSyntax
+    } else {
       self.parent?.scope
     }
   }
 }
 
 extension SourceFileSyntax: ScopeSyntax {
-  var parentScope: ScopeSyntax? {
-    nil
-  }
-
   var introducedNames: [LookupName] {
     []
   }
-
-  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
-    []
-  }
 }
 
 extension CodeBlockSyntax: ScopeSyntax {
   var introducedNames: [LookupName] {
     statements.flatMap { codeBlockItem in
-      LookupName.getNames(from: codeBlockItem.item)
+      LookupName.getNames(from: codeBlockItem.item, accessibleAfter: codeBlockItem.item.endPosition)
     }
   }
-
-  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
-    defaultLookupImplementation(for: name, at: syntax, positionSensitive: true)
-  }
 }
 
 extension ForStmtSyntax: ScopeSyntax {
   var introducedNames: [LookupName] {
     LookupName.getNames(from: pattern)
   }
-
-  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
-    defaultLookupImplementation(for: name, at: syntax)
-  }
 }
 
 extension ClosureExprSyntax: ScopeSyntax {
@@ -84,10 +55,6 @@ extension ClosureExprSyntax: ScopeSyntax {
       }
     } ?? []
   }
-
-  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
-    defaultLookupImplementation(for: name, at: syntax)
-  }
 }
 
 extension WhileStmtSyntax: ScopeSyntax {
@@ -96,10 +63,6 @@ extension WhileStmtSyntax: ScopeSyntax {
       LookupName.getNames(from: element.condition)
     }
   }
-
-  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
-    defaultLookupImplementation(for: name, at: syntax)
-  }
 }
 
 extension IfExprSyntax: ScopeSyntax {
@@ -124,15 +87,15 @@ extension IfExprSyntax: ScopeSyntax {
 
   var introducedNames: [LookupName] {
     conditions.flatMap { element in
-      LookupName.getNames(from: element.condition)
+      LookupName.getNames(from: element.condition, accessibleAfter: element.condition.endPosition)
     }
   }
 
   func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
     if let elseBody, elseBody.position <= syntax.position, elseBody.endPosition >= syntax.position {
       parentScope?.lookup(for: name, at: syntax) ?? []
     } else {
-      defaultLookupImplementation(for: name, at: syntax, positionSensitive: true)
+      defaultLookupImplementation(for: name, at: syntax)
     }
   }
 }
@@ -143,8 +106,4 @@ extension MemberBlockSyntax: ScopeSyntax {
       LookupName.getNames(from: member.decl)
     }
   }
-
-  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
-    defaultLookupImplementation(for: name, at: syntax)
-  }
 }

Sources/SwiftLexicalLookup/ScopeSyntax.swift

@@ -59,18 +59,22 @@ extension ScopeSyntax {
   var parentScope: ScopeSyntax? {
     self.parent?.scope
   }
+  
+  /// Returns all names introduced in this scope that `name` refers to and
+  /// is accessible at given syntax node then passes lookup to the parent.
+  func lookup(for name: String, at syntax: SyntaxProtocol) -> [LookupName] {
+    defaultLookupImplementation(for: name, at: syntax)
+  }
 
-  /// Returns all names introduced in this scope that `name` refers to and then
-  /// passes lookup to the parent. Optionally, if `positionSensitive` is set to `true`,
-  /// the method filters names that were introduced in this scope after `syntax`.
+  /// Returns all names introduced in this scope that `name` refers to and
+  /// is accessible at given syntax node then passes lookup to the parent.
   func defaultLookupImplementation(
     for name: String,
-    at syntax: SyntaxProtocol,
-    positionSensitive: Bool = false
+    at syntax: SyntaxProtocol
   ) -> [LookupName] {
     introducedNames
       .filter { introducedName in
-        (!positionSensitive || introducedName.isBefore(syntax)) && introducedName.refersTo(name)
+        introducedName.isAccessible(at: syntax) && introducedName.refersTo(name)
       } + (parentScope?.lookup(for: name, at: syntax) ?? [])
   }
 }

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -217,4 +217,28 @@ final class testNameLookup: XCTestCase {
       ])
     )
   }
+  
+  func testLookupInDeclaration() {
+    assertLexicalNameLookup(
+      source: """
+        class foo {
+          let 1️⃣a = 2️⃣a
+        
+          func foo() {
+            let 3️⃣a = 4️⃣a
+          
+            if let 5️⃣a = 6️⃣a {
+              let (a, b) = 8️⃣a
+            }
+          }
+        
+          let 9️⃣a = 0️⃣a
+        }
+        """,
+      references: ["2️⃣": ["1️⃣", "9️⃣"], "0️⃣": ["1️⃣", "9️⃣"], "4️⃣": ["1️⃣", "9️⃣"], "6️⃣": ["3️⃣", "1️⃣", "9️⃣"], "8️⃣": ["5️⃣", "3️⃣", "1️⃣", "9️⃣"]],
+      expectedResultTypes: .all(
+        IdentifierPatternSyntax.self
+      )
+    )
+  }
 }