[SwiftLexicalLookup][GSoC] Add proper guard scope and implicit name lookup

Sources/SwiftLexicalLookup/IdentifiableSyntax.swift

@@ -41,3 +41,9 @@ import SwiftSyntax
     expression.as(DeclReferenceExprSyntax.self)!.baseName
   }
 }
+
+@_spi(Experimental) extension AccessorParametersSyntax: IdentifiableSyntax {
+  @_spi(Experimental) public var identifier: TokenSyntax {
+    name
+  }
+}

Sources/SwiftLexicalLookup/IntroducingToSequentialParentScopeSyntax.swift

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 IntroducingToSequentialParentScopeSyntax: ScopeSyntax {
+  /// Returns names matching lookup that should be
+  /// handled by it's parent sequential scope.
+  func introducesToSequentialParent(
+    for identifier: Identifier?,
+    at origin: SyntaxProtocol,
+    with config: LookupConfig,
+    state: LookupState
+  ) -> [LookupResult]
+}

Sources/SwiftLexicalLookup/LookupName.swift

@@ -12,13 +12,93 @@
 
 import SwiftSyntax
 
+/// An entity that is implicitly declared based on the syntactic structure of the program.
+@_spi(Experimental) public enum ImplicitDecl {
+  /// `self` keyword representing object instance.
+  /// Could be associated with type declaration, extension,
+  /// or closure captures.
+  case `self`(DeclSyntaxProtocol)
+  /// `Self` keyword representing object type.
+  /// Could be associated with type declaration or extension.
+  case `Self`(DeclSyntaxProtocol)
+  /// `error` value caught by a `catch`
+  /// block that does not specify a catch pattern.
+  case error(CatchClauseSyntax)
+  /// `newValue` available by default inside `set` and `willSet`.
+  case newValue(AccessorDeclSyntax)
+  /// `oldValue` available by default inside `didSet`.
+  case oldValue(AccessorDeclSyntax)
+
+  /// Syntax associated with this name.
+  @_spi(Experimental) public var syntax: SyntaxProtocol {
+    switch self {
+    case .self(let syntax):
+      return syntax
+    case .Self(let syntax):
+      return syntax
+    case .error(let syntax):
+      return syntax
+    case .newValue(let syntax):
+      return syntax
+    case .oldValue(let syntax):
+      return syntax
+    }
+  }
+
+  /// The name of the implicit declaration.
+  private var name: String {
+    switch self {
+    case .self:
+      return "self"
+    case .Self:
+      return "Self"
+    case .error:
+      return "error"
+    case .newValue:
+      return "newValue"
+    case .oldValue:
+      return "oldValue"
+    }
+  }
+
+  /// Identifier used for name comparison.
+  ///
+  ///
+  /// ```swift
+  /// class Foo {
+  ///     func test() {
+  ///     let `Self` = "abc"
+  ///     print(Self.self)
+  ///
+  ///     let `self` = "def"
+  ///     print(self)
+  ///   }
+  /// }
+  ///
+  /// Foo().test()
+  /// ```
+  /// prints:
+  /// ```
+  /// abc
+  /// def
+  /// ```
+  /// `self` and `Self` identifers override
+  /// implicit `self` and `Self` introduced by
+  /// the `Foo` class declaration.
+  var identifier: Identifier {
+    Identifier(name)
+  }
+}
+
 @_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(IdentifiableSyntax, accessibleAfter: AbsolutePosition?)
   /// Declaration associated with the name.
   /// Could be class, struct, actor, protocol, function and more.
   case declaration(NamedDeclSyntax)
+  /// Name introduced implicitly by certain syntax nodes.
+  case implicit(ImplicitDecl)
 
   /// Syntax associated with this name.
   @_spi(Experimental) public var syntax: SyntaxProtocol {
@@ -27,16 +107,20 @@ import SwiftSyntax
       return syntax
     case .declaration(let syntax):
       return syntax
+    case .implicit(let implicitName):
+      return implicitName.syntax
     }
   }
 
-  /// Introduced name.
+  /// Identifier used for name comparison.
   @_spi(Experimental) public var identifier: Identifier? {
     switch self {
     case .identifier(let syntax, _):
-      return Identifier(syntax.identifier)
+      return Identifier(syntax.identifier) ?? Identifier(syntax.identifier.text)
     case .declaration(let syntax):
       return Identifier(syntax.name)
+    case .implicit(let kind):
+      return kind.identifier
     }
   }
 
@@ -58,9 +142,9 @@ import SwiftSyntax
   }
 
   /// Checks if this name refers to the looked up phrase.
-  func refersTo(_ lookedUpName: String) -> Bool {
-    guard let name = identifier?.name else { return false }
-    return name == lookedUpName
+  func refersTo(_ lookedUpIdentifier: Identifier) -> Bool {
+    guard let identifier else { return false }
+    return identifier == lookedUpIdentifier
   }
 
   /// Extracts names introduced by the given `syntax` structure.
@@ -105,10 +189,6 @@ import SwiftSyntax
       return functionCallExpr.arguments.flatMap { argument in
         getNames(from: argument.expression, accessibleAfter: accessibleAfter)
       }
-    case .guardStmt(let guardStmt):
-      return guardStmt.conditions.flatMap { cond in
-        getNames(from: cond.condition, accessibleAfter: cond.endPosition)
-      }
     default:
       if let namedDecl = Syntax(syntax).asProtocol(SyntaxProtocol.self) as? NamedDeclSyntax {
         return handle(namedDecl: namedDecl, accessibleAfter: accessibleAfter)
@@ -121,8 +201,10 @@ import SwiftSyntax
   }
 
   /// Extracts name introduced by `IdentifiableSyntax` node.
-  private static func handle(identifiable: IdentifiableSyntax, accessibleAfter: AbsolutePosition? = nil) -> [LookupName]
-  {
+  private static func handle(
+    identifiable: IdentifiableSyntax,
+    accessibleAfter: AbsolutePosition? = nil
+  ) -> [LookupName] {
     if identifiable.identifier.tokenKind != .wildcard {
       return [.identifier(identifiable, accessibleAfter: accessibleAfter)]
     } else {

Sources/SwiftLexicalLookup/LookupState.swift

@@ -0,0 +1,19 @@
+//===----------------------------------------------------------------------===//
+//
+// 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 Foundation
+
+/// Represents internal state for lookup.
+/// It shouldn't be used by clients.
+@_spi(Experimental) public struct LookupState {
+  init() {}
+}