[5.7][CSClosure] Mark partially inferred external declarations as invalid

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};

lib/Sema/CSStep.h

@@ -781,6 +781,9 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
   class SolverSnapshot {
     ConstraintSystem &CS;
 
+    /// The conjunction this snapshot belongs to.
+    Constraint *Conjunction;
+
     Optional<llvm::SaveAndRestore<DeclContext *>> DC = None;
 
     llvm::SetVector<TypeVariableType *> TypeVars;
@@ -794,8 +797,9 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
 
   public:
     SolverSnapshot(ConstraintSystem &cs, Constraint *conjunction)
-        : CS(cs), TypeVars(std::move(cs.TypeVariables)) {
-      auto *locator = conjunction->getLocator();
+        : CS(cs), Conjunction(conjunction),
+          TypeVars(std::move(cs.TypeVariables)) {
+      auto *locator = Conjunction->getLocator();
       // If this conjunction represents a closure, we need to
       // switch declaration context over to it.
       if (locator->directlyAt<ClosureExpr>()) {
@@ -820,7 +824,7 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
       IsolationScope = std::make_unique<Scope>(CS);
 
       // Apply solution inferred for the conjunction.
-      CS.applySolution(solution);
+      applySolution(solution);
 
       // Add constraints to the graph after solution
       // has been applied to make sure that all type
@@ -855,6 +859,36 @@ class ConjunctionStep : public BindingStep<ConjunctionElementProducer> {
       for (auto &constraint : CS.InactiveConstraints)
         CG.addConstraint(&constraint);
     }
+
+    void applySolution(const Solution &solution) {
+      CS.applySolution(solution);
+
+      if (!CS.shouldAttemptFixes())
+        return;
+
+      // If inference succeeded, we are done.
+      auto score = solution.getFixedScore();
+      if (score.Data[SK_Fix] == 0)
+        return;
+
+      // If this conjunction represents a closure and inference
+      // has failed, let's bind all of unresolved type variables
+      // in its interface type to holes to avoid extraneous
+      // fixes produced by outer context.
+
+      auto locator = Conjunction->getLocator();
+      if (locator->directlyAt<ClosureExpr>()) {
+        auto closureTy =
+            CS.getClosureType(castToExpr<ClosureExpr>(locator->getAnchor()));
+
+        CS.simplifyType(closureTy).visit([&](Type componentTy) {
+          if (auto *typeVar = componentTy->getAs<TypeVariableType>()) {
+            CS.assignFixedType(
+                typeVar, PlaceholderType::get(CS.getASTContext(), typeVar));
+          }
+        });
+      }
+    }
   };
 
   /// Best solution solver reached so far.

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
+  }
+}