[CSGen] Detect nested out-of-scope variables in recursive declarations

Follow-up to swiftlang#63505

Since, when the type is not stated, a variable assumes the
type of its initializer that enables out-of-scope variables
to be nested inside of some other concrete type i.e. Optional.

Resolves: swiftlang#63455

Author: xedin

lib/Sema/CSGen.cpp

@@ -1368,13 +1368,19 @@ namespace {
           knownType = CS.getVarType(VD);
 
         if (knownType) {
-          // An out-of-scope type variable could be a type of a declaration
-          // only in diagnostic mode when invalid variable declaration is
-          // recursively referenced inside of a multi-statement closure
-          // located somewhere within its initializer e.g.:
-          // `let x = [<call>] { ... print(x) }`
-          if (auto *typeVar = knownType->getAs<TypeVariableType>()) {
-            if (!CS.isActiveTypeVariable(typeVar))
+          // An out-of-scope type variable(s) could appear the type of
+          // a declaration only in diagnostic mode when invalid variable
+          // declaration is recursively referenced inside of a multi-statement
+          // closure located somewhere within its initializer e.g.:
+          // `let x = [<call>] { ... print(x) }`. It happens because the
+          // variable assumes the result type of its initializer unless
+          // its specified explicitly.
+          if (knownType->hasTypeVariable()) {
+            llvm::SmallPtrSet<TypeVariableType *, 2> typeVars;
+            knownType->getTypeVariables(typeVars);
+            if (llvm::any_of(typeVars, [&](auto *typeVar) {
+                  return !CS.isActiveTypeVariable(typeVar);
+                }))
               return invalidateReference();
           }
 

test/expr/closure/multi_statement.swift

@@ -653,13 +653,29 @@ func test_that_closures_are_attempted_in_order() {
 
 // https://github.com/apple/swift/issues/63455
 func test_recursive_var_reference_in_multistatement_closure() {
+  struct MyStruct {
+    func someMethod() {}
+  }
+
   func takeClosure(_ x: () -> Void) {}
 
-  func test(optionalInt: Int?) {
+  func test(optionalInt: Int?, themes: MyStruct?) {
     takeClosure {
       let int = optionalInt { // expected-error {{cannot call value of non-function type 'Int?'}}
         print(int)
       }
     }
+
+    takeClosure {
+      let theme = themes?.someMethod() { // expected-error {{extra trailing closure passed in call}}
+        _ = theme
+      }
+    }
+
+    takeClosure {
+      let theme = themes?.filter({ $0 }) { // expected-error {{value of type 'MyStruct' has no member 'filter'}}
+        _ = theme
+      }
+    }
   }
 }