Merge pull request #70409 from xedin/rdar-119001449

[ConstraintSystem] Run `salvage` even if diagnostics are suppressed

Author: xedin

lib/Sema/CSSolver.cpp

@@ -1515,14 +1515,6 @@ ConstraintSystem::solve(SyntacticElementTarget &target,
       LLVM_FALLTHROUGH;
 
     case SolutionResult::UndiagnosedError:
-      /// If we have a SolutionCallback, we are inspecting constraint system
-      /// solutions directly and thus also want to receive ambiguous solutions.
-      /// Hence always run the second (salvaging) stage.
-      if (shouldSuppressDiagnostics() && !Context.SolutionCallback) {
-        solution.markAsDiagnosed();
-        return llvm::None;
-      }
-
       if (stage == 1) {
         diagnoseFailureFor(target);
         reportSolutionsToSolutionCallback(solution);

lib/Sema/ConstraintSystem.cpp

@@ -4389,6 +4389,10 @@ SolutionResult ConstraintSystem::salvage() {
       return SolutionResult::forSolved(std::move(viable[0]));
     }
 
+    if (shouldSuppressDiagnostics())
+      return viable.empty() ? SolutionResult::forUndiagnosedError()
+                            : SolutionResult::forAmbiguous(viable);
+
     // FIXME: If we were able to actually fix things along the way,
     // we may have to hunt for the best solution. For now, we don't care.
 
@@ -5228,7 +5232,7 @@ static bool diagnoseContextualFunctionCallGenericAmbiguity(
 
 bool ConstraintSystem::diagnoseAmbiguityWithFixes(
     SmallVectorImpl<Solution> &solutions) {
-  if (solutions.empty())
+  if (solutions.empty() || shouldSuppressDiagnostics())
     return false;
 
   SolutionDiff solutionDiff(solutions);

lib/Sema/TypeCheckCodeCompletion.cpp

@@ -59,8 +59,7 @@ using namespace constraints;
 
 static Type
 getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
-                                   ConcreteDeclRef &referencedDecl,
-                                 FreeTypeVariableBinding allowFreeTypeVariables) {
+                                   ConcreteDeclRef &referencedDecl) {
   if (isa<AbstractClosureExpr>(dc)) {
     // If the expression is embedded in a closure, the constraint system tries
     // to retrieve that closure's type, which will fail since we won't have
@@ -95,15 +94,18 @@ getTypeOfExpressionWithoutApplying(Expr *&expr, DeclContext *dc,
     expr->setType(Type());
   SyntacticElementTarget target(expr, dc, CTP_Unused, Type(),
                                 /*isDiscarded=*/false);
-  auto viable = cs.solve(target, allowFreeTypeVariables);
-  if (!viable) {
+
+  SmallVector<Solution, 2> viable;
+  cs.solveForCodeCompletion(target, viable);
+
+  if (viable.empty()) {
     recoverOriginalType();
     return Type();
   }
 
   // Get the expression's simplified type.
   expr = target.getAsExpr();
-  auto &solution = (*viable)[0];
+  auto &solution = viable.front();
   auto &solutionCS = solution.getConstraintSystem();
   Type exprType = solution.simplifyType(solutionCS.getType(expr));
 
@@ -332,8 +334,8 @@ getTypeOfCompletionContextExpr(DeclContext *DC, CompletionTypeCheckKind kind,
   }
 
   Type originalType = parsedExpr->getType();
-  if (auto T = getTypeOfExpressionWithoutApplying(parsedExpr, DC,
-                 referencedDecl, FreeTypeVariableBinding::UnresolvedType))
+  if (auto T =
+          getTypeOfExpressionWithoutApplying(parsedExpr, DC, referencedDecl))
     return T;
 
   // Try to recover if we've made any progress.