Merge pull request #29778 from DougGregor/more-sinking

[Constraint system] Sink optional “some” pattern handling into constrain generation

Author: DougGregor

lib/Sema/CSApply.cpp

@@ -7441,6 +7441,13 @@ Optional<SolutionApplicationTarget> ConstraintSystem::applySolution(
 
     solution.setExprTypes(resultExpr);
     result.setExpr(resultExpr);
+
+    if (Context.TypeCheckerOpts.DebugConstraintSolver) {
+      auto &log = Context.TypeCheckerDebug->getStream();
+      log << "---Type-checked expression---\n";
+      resultExpr->dump(log);
+      log << "\n";
+    }
   }
 
   rewriter.finalize();

lib/Sema/CSGen.cpp

@@ -3897,11 +3897,17 @@ bool ConstraintSystem::generateConstraints(
     SolutionApplicationTarget &target,
     FreeTypeVariableBinding allowFreeTypeVariables) {
   if (Expr *expr = target.getAsExpr()) {
-    // Try to shrink the system by reducing disjunction domains. This
-    // goes through every sub-expression and generate its own sub-system, to
-    // try to reduce the domains of those subexpressions.
-    shrink(expr);
-    target.setExpr(expr);
+    // If the target requires an optional of some type, form a new appropriate
+    // type variable and update the target's type with an optional of that
+    // type variable.
+    if (target.isOptionalSomePatternInit()) {
+      assert(!target.getExprContextualType() &&
+             "some pattern cannot have contextual type pre-configured");
+      auto *convertTypeLocator =
+          getConstraintLocator(expr, LocatorPathElt::ContextualType());
+      Type var = createTypeVariable(convertTypeLocator, TVO_CanBindToNoEscape);
+      target.setExprConversionType(TypeChecker::getOptionalType(expr->getLoc(), var));
+    }
 
     // Generate constraints for the main system.
     expr = generateConstraints(expr, target.getDeclContext());
@@ -3941,6 +3947,14 @@ bool ConstraintSystem::generateConstraints(
       return true;
     }
 
+    if (getASTContext().TypeCheckerOpts.DebugConstraintSolver) {
+      auto &log = getASTContext().TypeCheckerDebug->getStream();
+      log << "---Initial constraints for the given expression---\n";
+      print(log, expr);
+      log << "\n";
+      print(log);
+    }
+
     return false;
   }
 

lib/Sema/CSSolver.cpp

@@ -1252,17 +1252,10 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
     return SolutionResult::forError();;
 
   // Notify the listener that we've built the constraint system.
-  Expr *expr = target.getAsExpr();
-  if (listener && listener->builtConstraints(*this, expr)) {
-    return SolutionResult::forError();
-  }
-
-  if (getASTContext().TypeCheckerOpts.DebugConstraintSolver) {
-    auto &log = getASTContext().TypeCheckerDebug->getStream();
-    log << "---Initial constraints for the given expression---\n";
-    print(log, expr);
-    log << "\n";
-    print(log);
+  if (Expr *expr = target.getAsExpr()) {
+    if (listener && listener->builtConstraints(*this, expr)) {
+      return SolutionResult::forError();
+    }
   }
 
   // Try to solve the constraint system using computed suggestions.
@@ -1272,8 +1265,6 @@ ConstraintSystem::solveImpl(SolutionApplicationTarget &target,
   if (getExpressionTooComplex(solutions))
     return SolutionResult::forTooComplex();
 
-  target.setExpr(expr);
-
   switch (solutions.size()) {
   case 0:
     return SolutionResult::forUndiagnosedError();

lib/Sema/TypeCheckConstraints.cpp

@@ -2079,24 +2079,18 @@ TypeChecker::typeCheckExpression(
       target.getExprContextualTypeLoc(),
       target.getExprContextualTypePurpose());
 
+  // Try to shrink the system by reducing disjunction domains. This
+  // goes through every sub-expression and generate its own sub-system, to
+  // try to reduce the domains of those subexpressions.
+  cs.shrink(expr);
+  target.setExpr(expr);
+
   // If the client can handle unresolved type variables, leave them in the
   // system.
   auto allowFreeTypeVariables = FreeTypeVariableBinding::Disallow;
   if (options.contains(TypeCheckExprFlags::AllowUnresolvedTypeVariables))
     allowFreeTypeVariables = FreeTypeVariableBinding::UnresolvedType;
 
-  // If the target requires an optional of some type, form a new appropriate
-  // type variable and update the target's type with an optional of that
-  // type variable.
-  if (target.isOptionalSomePatternInit()) {
-    assert(!target.getExprContextualType() &&
-           "some pattern cannot have contextual type pre-configured");
-    auto *convertTypeLocator =
-        cs.getConstraintLocator(expr, LocatorPathElt::ContextualType());
-    Type var = cs.createTypeVariable(convertTypeLocator, TVO_CanBindToNoEscape);
-    target.setExprConversionType(getOptionalType(expr->getLoc(), var));
-  }
-
   // Attempt to solve the constraint system.
   auto viable = cs.solve(target, listener, allowFreeTypeVariables);
   if (!viable) {
@@ -2138,13 +2132,6 @@ TypeChecker::typeCheckExpression(
       return None;
   }
 
-  if (Context.TypeCheckerOpts.DebugConstraintSolver) {
-    auto &log = Context.TypeCheckerDebug->getStream();
-    log << "---Type-checked expression---\n";
-    result->dump(log);
-    log << "\n";
-  }
-
   // Unless the client has disabled them, perform syntactic checks on the
   // expression now.
   if (!cs.shouldSuppressDiagnostics() &&