[CSClosure] Mark partially inferred external declarations as invalid

If a syntactic element references an external declaration (relative
to its own context), let's check whether it has any type variables,
and if so, replace them with errors to remove any possibility of
bringing external constraints into element's scope.

Resolves: rdar://92347054

Author: xedin

lib/Sema/CSClosure.cpp

@@ -50,8 +50,32 @@ class TypeVariableRefFinder : public ASTWalker {
 
   std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
     if (auto *DRE = dyn_cast<DeclRefExpr>(expr)) {
-      if (auto type = CS.getTypeIfAvailable(DRE->getDecl()))
+      auto *decl = DRE->getDecl();
+
+      if (auto type = CS.getTypeIfAvailable(DRE->getDecl())) {
+        // If this is not one of the closure parameters which
+        // is inferrable from the body, let's replace type
+        // variables with errors to avoid bringing external
+        // information to the element component.
+        if (type->hasTypeVariable() && !isa<ParamDecl>(decl)) {
+          // If there are type variables left in the simplified version,
+          // it means that this is an invalid external declaration
+          // relative to this element's context.
+          if (CS.simplifyType(type)->hasTypeVariable()) {
+            auto transformedTy = type.transform([&](Type type) {
+              if (auto *typeVar = type->getAs<TypeVariableType>()) {
+                return ErrorType::get(CS.getASTContext());
+              }
+              return type;
+            });
+
+            CS.setType(decl, transformedTy);
+            return {true, expr};
+          }
+        }
+
         inferVariables(type);
+      }
     }
 
     return {true, expr};

test/expr/closure/multi_statement.swift

@@ -329,3 +329,24 @@ func test_unknown_refs_in_tilde_operator() {
     }
   }
 }
+
+// rdar://92347054 - crash during conjunction processing
+func test_no_crash_with_circular_ref_due_to_error() {
+  struct S { // expected-note {{did you mean 'S'?}}
+    var x: Int?
+  }
+
+  func test(v: Int?, arr: [S]) -> Int { // expected-note {{did you mean 'v'?}}
+    // There is missing `f` here which made body of the
+    // `if` a multiple statement closure instead that uses
+    // `next` inside.
+    i let x = v, let next = arr.first?.x { // expected-error {{cannot find 'i' in scope}}
+      // expected-error@-1 {{consecutive statements on a line must be separated by ';'}}
+      // expected-error@-2 {{'let' cannot appear nested inside another 'var' or 'let' pattern}}
+      // expected-error@-3 {{cannot call value of non-function type 'Int?'}}
+      print(next)
+      return x
+    }
+    return 0
+  }
+}