[ConstraintSystem] NFC: Drop Expression from isTooComplex check

Solver can now handle multiple different targets e.g. multi-statement
closures, result builders etc. So it's more appropriate to say that
the constraint system is too complex.

(cherry picked from commit 7dab90c)

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -5415,9 +5415,9 @@ class ConstraintSystem {
 
   /// Determine if we've already explored too many paths in an
   /// attempt to solve this expression.
-  bool isExpressionAlreadyTooComplex = false;
-  bool getExpressionTooComplex(size_t solutionMemory) {
-    if (isExpressionAlreadyTooComplex)
+  bool isAlreadyTooComplex = false;
+  bool isTooComplex(size_t solutionMemory) {
+    if (isAlreadyTooComplex)
       return true;
 
     auto CancellationFlag = getASTContext().CancellationFlag;
@@ -5428,7 +5428,7 @@ class ConstraintSystem {
     MaxMemory = std::max(used, MaxMemory);
     auto threshold = getASTContext().TypeCheckerOpts.SolverMemoryThreshold;
     if (MaxMemory > threshold) {
-      return isExpressionAlreadyTooComplex= true;
+      return isAlreadyTooComplex= true;
     }
 
     if (Timer && Timer->isExpired()) {
@@ -5437,27 +5437,27 @@ class ConstraintSystem {
       // emitting an error.
       Timer->disableWarning();
 
-      return isExpressionAlreadyTooComplex = true;
+      return isAlreadyTooComplex = true;
     }
 
     // Bail out once we've looked at a really large number of
     // choices.
     if (CountScopes > getASTContext().TypeCheckerOpts.SolverBindingThreshold) {
-      return isExpressionAlreadyTooComplex = true;
+      return isAlreadyTooComplex = true;
     }
 
     return false;
   }
 
-  bool getExpressionTooComplex(SmallVectorImpl<Solution> const &solutions) {
-    if (isExpressionAlreadyTooComplex)
+  bool isTooComplex(SmallVectorImpl<Solution> const &solutions) {
+    if (isAlreadyTooComplex)
       return true;
 
     size_t solutionMemory = 0;
     for (auto const& s : solutions) {
       solutionMemory += s.getTotalMemory();
     }
-    return getExpressionTooComplex(solutionMemory);
+    return isTooComplex(solutionMemory);
   }
 
   // If the given constraint is an applied disjunction, get the argument function

lib/Sema/CSSolver.cpp

@@ -1374,7 +1374,7 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
   SmallVector<Solution, 4> solutions;
   solve(solutions, allowFreeTypeVariables);
 
-  if (getExpressionTooComplex(solutions))
+  if (isTooComplex(solutions))
     return SolutionResult::forTooComplex();
 
   switch (solutions.size()) {
@@ -1415,7 +1415,7 @@ bool ConstraintSystem::solve(SmallVectorImpl<Solution> &solutions,
   filterSolutions(solutions);
 
   // We fail if there is no solution or the expression was too complex.
-  return solutions.empty() || getExpressionTooComplex(solutions);
+  return solutions.empty() || isTooComplex(solutions);
 }
 
 void ConstraintSystem::solveImpl(SmallVectorImpl<Solution> &solutions) {

lib/Sema/CSStep.cpp

@@ -251,7 +251,7 @@ bool SplitterStep::mergePartialSolutions() const {
 
     // Since merging partial solutions can go exponential, make sure we didn't
     // pass the "too complex" thresholds including allocated memory and time.
-    if (CS.getExpressionTooComplex(solutionMemory))
+    if (CS.isTooComplex(solutionMemory))
       return false;
 
   } while (nextCombination(counts, indices));
@@ -313,7 +313,7 @@ StepResult ComponentStep::take(bool prevFailed) {
   // One of the previous components created by "split"
   // failed, it means that we can't solve this component.
   if ((prevFailed && DependsOnPartialSolutions.empty()) ||
-      CS.getExpressionTooComplex(Solutions))
+      CS.isTooComplex(Solutions))
     return done(/*isSuccess=*/false);
 
   // Setup active scope, only if previous component didn't fail.

lib/Sema/CSStep.h

@@ -506,7 +506,7 @@ template <typename P> class BindingStep : public SolverStep {
   StepResult take(bool prevFailed) override {
     // Before attempting the next choice, let's check whether the constraint
     // system is too complex already.
-    if (CS.getExpressionTooComplex(Solutions))
+    if (CS.isTooComplex(Solutions))
       return done(/*isSuccess=*/false);
 
     while (auto choice = Producer()) {

lib/Sema/ConstraintSystem.cpp

@@ -3776,7 +3776,7 @@ SolutionResult ConstraintSystem::salvage() {
     // Fall through to produce diagnostics.
   }
 
-  if (getExpressionTooComplex(viable))
+  if (isTooComplex(viable))
     return SolutionResult::forTooComplex();
 
   // Could not produce a specific diagnostic; punt to the client.