Add suggested changes.

Author: MAJKFL

Sources/SwiftLexicalLookup/CMakeLists.txt

@@ -25,5 +25,5 @@ add_swift_syntax_library(SwiftLexicalLookup
 )
 
 target_link_swift_syntax_libraries(SwiftLexicalLookup PUBLIC
-SwiftSyntax)
+  SwiftSyntax)
 

Sources/SwiftLexicalLookup/Scopes/GenericParameterScopeSyntax.swift

@@ -13,16 +13,16 @@
 import SwiftSyntax
 
 /// Scope that introduces generic parameter names and directs
-/// futher lookup to it's `WithGenericParametersScopeSyntax`
+/// futher lookup to its `WithGenericParametersScopeSyntax`
 /// parent scope's parent scope (i.e. on return, bypasses names
-/// introduced by it's parent).
+/// introduced by its parent).
 @_spi(Experimental) public protocol GenericParameterScopeSyntax: ScopeSyntax {}
 
 @_spi(Experimental) extension GenericParameterScopeSyntax {
   /// Returns names matching lookup and bypasses
   /// `WithGenericParametersScopeSyntax` parent scope in futher lookup.
   ///
-  /// example:
+  /// ### Example
   /// ```swift
   /// let a = 23
   /// func foo<A>(a: A) {
@@ -57,7 +57,7 @@ import SwiftSyntax
 
   /// Bypasses names introduced by `WithGenericParametersScopeSyntax` parent scope.
   ///
-  /// example:
+  /// ### Example
   /// ```swift
   /// let a = 23
   /// func foo<A>(a: A) {

Sources/SwiftLexicalLookup/Scopes/ScopeImplementations.swift

@@ -176,7 +176,7 @@ import SwiftSyntax
   /// All names introduced by the closure signature.
   /// Could be closure captures or (shorthand) parameters.
   ///
-  /// Example:
+  /// ### Example
   /// ```swift
   /// let x = { [weak self, a] b, _ in
   ///   // <--
@@ -222,7 +222,7 @@ import SwiftSyntax
 
   /// Finds parent scope, omitting ancestor `if` statements if part of their `else if` clause.
   ///
-  /// Example:
+  /// ### Example
   /// ```swift
   /// func foo() {
   ///   if let a = x {
@@ -262,7 +262,7 @@ import SwiftSyntax
   /// Lookup triggered from inside of `else`
   /// clause is immediately forwarded to parent scope.
   ///
-  /// Example:
+  /// ### Example
   /// ```swift
   /// if let a = x {
   ///   // <-- a is visible here
@@ -326,7 +326,7 @@ import SwiftSyntax
   /// Lookup triggered from within of the `else` body
   /// returns no names.
   ///
-  /// Example:
+  /// ### Example
   /// ```swift
   /// guard let a = x else {
   ///   return // a is not visible here
@@ -399,7 +399,7 @@ import SwiftSyntax
   /// all associated type declarations made inside the
   /// protocol member block.
   ///
-  /// example:
+  /// ### Example
   /// ```swift
   /// class A {}
   ///
@@ -436,7 +436,7 @@ import SwiftSyntax
 @_spi(Experimental) extension GenericParameterClauseSyntax: GenericParameterScopeSyntax {
   /// Generic parameter names introduced by this clause.
   @_spi(Experimental) public var introducedNames: [LookupName] {
-    parameters.children(viewMode: .sourceAccurate).flatMap { child in
+    parameters.children(viewMode: .fixedUp).flatMap { child in
       LookupName.getNames(from: child, accessibleAfter: child.endPosition)
     }
   }
@@ -450,3 +450,19 @@ import SwiftSyntax
     }
   }
 }
+
+@_spi(Experimental) extension SubscriptDeclSyntax: WithGenericParametersScopeSyntax {
+  /// Parameters introduced by this subscript.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    parameterClause.parameters.flatMap { parameter in
+      LookupName.getNames(from: parameter)
+    }
+  }
+}
+
+@_spi(Experimental) extension TypeAliasDeclSyntax: WithGenericParametersScopeSyntax {
+  /// Type alias doesn't introduce any names to it's children.
+  @_spi(Experimental) public var introducedNames: [LookupName] {
+    []
+  }
+}

Sources/SwiftLexicalLookup/Scopes/SequentialScopeSyntax.swift

@@ -22,7 +22,7 @@ extension SequentialScopeSyntax {
   /// and included `IntroducingToSequentialParentScopeSyntax` children
   /// scopes that match the lookup.
   ///
-  /// Example:
+  /// ### Example
   /// ```swift
   /// func foo() {
   ///   let a = 1

Sources/SwiftLexicalLookup/Scopes/WithGenericParametersScopeSyntax.swift

@@ -20,7 +20,7 @@ import SwiftSyntax
   /// Returns names matching lookup and passes lookup to
   /// the generic parameter clause scopes.
   ///
-  /// example:
+  /// ### Example
   /// ```swift
   /// let a = 23
   /// func foo<A>(a: A) {
@@ -54,7 +54,7 @@ import SwiftSyntax
   /// Passes lookup to this scope's generic parameter or
   /// primary associated type clause scope (`WithGenericParametersScopeSyntax`).
   ///
-  /// example:
+  /// ### Example
   /// ```swift
   /// let a = 23
   /// func foo<A>(a: A) {

Tests/SwiftLexicalLookupTest/NameLookupTests.swift

@@ -968,4 +968,54 @@ final class testNameLookup: XCTestCase {
       )
     )
   }
+
+  func testSubscript() {
+    assertLexicalNameLookup(
+      source: """
+        class X {
+          let 0️⃣c = 123
+
+          subscript<1️⃣A, 2️⃣B>(3️⃣a: 4️⃣A, 5️⃣b: 6️⃣B) -> 7️⃣B {
+            return 8️⃣a + 9️⃣b + 🔟c
+          }
+        }
+        """,
+      references: [
+        "4️⃣": [.fromScope(GenericParameterClauseSyntax.self, expectedNames: ["1️⃣"])],
+        "6️⃣": [.fromScope(GenericParameterClauseSyntax.self, expectedNames: ["2️⃣"])],
+        "7️⃣": [.fromScope(GenericParameterClauseSyntax.self, expectedNames: ["2️⃣"])],
+        "8️⃣": [.fromScope(SubscriptDeclSyntax.self, expectedNames: ["3️⃣"])],
+        "9️⃣": [.fromScope(SubscriptDeclSyntax.self, expectedNames: ["5️⃣"])],
+        "🔟": [.fromScope(MemberBlockSyntax.self, expectedNames: ["0️⃣"])],
+      ],
+      expectedResultTypes: .all(
+        GenericParameterSyntax.self,
+        except: [
+          "0️⃣": IdentifierPatternSyntax.self,
+          "3️⃣": FunctionParameterSyntax.self,
+          "5️⃣": FunctionParameterSyntax.self,
+        ]
+      )
+    )
+  }
+
+  func testTypealias() {
+    assertLexicalNameLookup(
+      source: """
+        typealias SomeType<1️⃣A> = X<2️⃣A, 3️⃣NoMatch>
+
+        7️⃣typealias SomeOtherType<4️⃣A> = X<5️⃣A, 6️⃣SomeOtherType>
+        """,
+      references: [
+        "2️⃣": [.fromScope(GenericParameterClauseSyntax.self, expectedNames: ["1️⃣"])],
+        "3️⃣": [],
+        "5️⃣": [.fromScope(GenericParameterClauseSyntax.self, expectedNames: ["4️⃣"])],
+        "6️⃣": [.fromFileScope(expectedNames: ["7️⃣"])],
+      ],
+      expectedResultTypes: .all(
+        GenericParameterSyntax.self,
+        except: ["7️⃣": TypeAliasDeclSyntax.self]
+      )
+    )
+  }
 }