Add a basic SwiftLexicalLookup validation test. Add caching of ConfiguredRegions to unqualified lookup validation.

Author: MAJKFL

lib/ASTGen/Sources/ASTGen/LexicalLookup.swift

@@ -38,7 +38,7 @@ private let rowCharWidth: Int = 30
 /// Additionally, when matching fails, the function prints console output with the two results compared.
 @_cdecl("swift_ASTGen_validateUnqualifiedLookup")
 public func unqualifiedLookup(
-  sourceFilePtr: UnsafeRawPointer,
+  sourceFilePtr: UnsafeMutableRawPointer,
   astContext: BridgedASTContext,
   lookupAt: BridgedSourceLoc,
   finishInSequentialScope: Bool,
@@ -51,10 +51,7 @@ public func unqualifiedLookup(
     return false
   }
   let sourceLocationConverter = sourceFile.pointee.sourceLocationConverter
-  let buildConfiguration = CompilerBuildConfiguration(
-    ctx: astContext,
-    sourceBuffer: sourceFile.pointee.buffer
-  )
+  let configuredRegions = sourceFile.pointee.configuredRegions(astContext: astContext)
 
   guard let lookupPosition = sourceFile.pointee.position(of: lookupAt),
     let lookupToken = sourceFileSyntax.token(at: lookupPosition)
@@ -73,7 +70,7 @@ public func unqualifiedLookup(
   let sllResults = sllConsumedResults(
     lookupToken: lookupToken,
     finishInSequentialScope: finishInSequentialScope,
-    configuredRegions: sourceFileSyntax.configuredRegions(in: buildConfiguration)
+    configuredRegions: configuredRegions
   )
 
   // Add header to the output
@@ -201,11 +198,39 @@ private func sllConsumedResults(
   finishInSequentialScope: Bool,
   configuredRegions: ConfiguredRegions
 ) -> [ConsumedLookupResult] {
-  lookupToken.lookup(
+  let resultsWithoutMacroReordering = lookupToken.lookup(
     nil,
     with: LookupConfig(finishInSequentialScope: finishInSequentialScope, configuredRegions: configuredRegions)
   )
-  .flatMap { result in
+
+  // Early reordering of macro declaration parameters with its generic parameters.
+  var results: [LookupResult] = []
+  var previousMacroResult: LookupResult?
+
+  for result in resultsWithoutMacroReordering {
+    if let unwrappedMacroResult = previousMacroResult,
+      result.scope.is(GenericParameterClauseSyntax.self)
+    {
+      results += [result, unwrappedMacroResult]
+      previousMacroResult = nil
+      continue
+    } else if let unwrappedMacroResult = previousMacroResult {
+      results.append(unwrappedMacroResult)
+      previousMacroResult = nil
+    }
+
+    if result.scope.is(MacroDeclSyntax.self) {
+      previousMacroResult = result
+    } else {
+      results.append(result)
+    }
+  }
+
+  if let previousMacroResult {
+    results.append(previousMacroResult)
+  }
+
+  return results.flatMap { result in
     switch result {
     case .lookInMembers(let lookInMembers):
       return [

test/NameLookup/SwiftLexicalLookupValidation/testGenericWhereClause.swift

@@ -0,0 +1,73 @@
+// RUN: %target-typecheck-verify-swift -enable-experimental-feature UnqualifiedLookupValidation
+
+protocol P1 {
+    associatedtype A
+    func f() -> A
+}
+
+protocol P2 {
+    associatedtype A: P2
+    associatedtype B: P2 where Self.A.A == Self.B.A
+}
+
+protocol P3 {
+    associatedtype A: P3
+}
+
+struct Basic: P1 {
+    typealias A = Int
+    func f() -> Int { fatalError() }
+}
+
+struct Recur: P2 {
+    typealias A = Recur
+    typealias B = Recur
+}
+
+struct NonRecur: P2 {
+    typealias A = Recur
+    typealias B = Recur
+}
+
+struct Generic<T> {}
+
+class Super<T, U> {}
+
+extension Super: P2 where T: P2, U: P2 {
+    typealias A = T
+    typealias B = T
+  
+    func foo() -> Int { fatalError() }
+}
+
+class Sub: Super<NonRecur, Recur> {}
+
+struct RecurGeneric<T: P3>: P3 {
+    typealias A = RecurGeneric<T>
+}
+
+struct Specialize: P3 {
+    typealias A = RecurGeneric<Specialize>
+}
+
+protocol P48a { associatedtype A = Int }
+protocol P48b { associatedtype B }
+protocol P48c: P48a, P48b where A == B {}
+
+public extension Array where Element == Int {
+  mutating func foo(
+    at index: Int,
+    byCalling closure: (inout Element) -> Void
+  ) where Element: Differentiable { // expected-error{{cannot find type 'Differentiable' in scope}}
+    closure(&self[index])
+  }
+}
+
+public extension Array {
+  mutating func bar(
+    at index: Int,
+    byCalling closure:(inout Element) -> Void
+  ) where Element: Differentiable { // expected-error{{cannot find type 'Differentiable' in scope}}
+    closure(&self[index])
+  }
+}