---

yaml
---
r: 341215
b: refs/heads/rxwei-patch-1
c: 5c33156
h: refs/heads/master
i:
  341213: 8885165
  341211: 23a65ac
  341207: b03b577
  341199: 2f46e41
  341183: 78e2498

Author: LucianoPAlmeida

[refs]

@@ -1015,7 +1015,7 @@ refs/tags/swift-DEVELOPMENT-SNAPSHOT-2018-08-18-a: b10b1fce14385faa6d44f6b933e95
 refs/heads/rdar-43033749-fix-batch-mode-no-diags-swift-5.0-branch: a14e64eaad30de89f0f5f0b2a782eed7ecdcb255
 refs/heads/revert-19006-error-bridging-integer-type: 8a9065a3696535305ea53fe9b71f91cbe6702019
 refs/heads/revert-19050-revert-19006-error-bridging-integer-type: ecf752d54b05dd0a20f510f0bfa54a3fec3bcaca
-refs/heads/rxwei-patch-1: 2ef18488d65486ddaec924baeac97bb10e9f2dfb
+refs/heads/rxwei-patch-1: 5c33156417cd8b5b5d3e36bb5515b2f63b290b73
 refs/heads/shahmishal-patch-1: e58ec0f7488258d42bef51bc3e6d7b3dc74d7b2a
 refs/heads/typelist-existential: 4046359efd541fb5c72d69a92eefc0a784df8f5e
 refs/tags/swift-4.2-DEVELOPMENT-SNAPSHOT-2018-08-20-a: 4319ba09e4fb8650ee86061075c74a016b6baab9

branches/rxwei-patch-1/lib/Sema/CSApply.cpp

@@ -3707,7 +3707,7 @@ namespace {
         Expr *sub = expr->getSubExpr();
 
         cs.setExprTypes(sub);
-        if (tc.convertToType(sub, toType, cs.DC))
+        if (tc.convertToType(sub, toType, cs))
           return nullptr;
         cs.cacheExprTypes(sub);
 

branches/rxwei-patch-1/lib/Sema/TypeCheckConstraints.cpp

@@ -2868,7 +2868,7 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       SequenceType = solution.simplifyType(SequenceType);
 
       // Perform any necessary conversions of the sequence (e.g. [T]! -> [T]).
-      if (tc.convertToType(expr, SequenceType, cs.DC)) {
+      if (solution.coerceToType(expr, SequenceType, cs.getConstraintLocator(expr))) {
         return nullptr;
       }
 
@@ -3318,64 +3318,66 @@ Expr *TypeChecker::coerceToRValue(Expr *expr,
   return expr;
 }
 
+bool TypeChecker::convertToType(Expr *&expr, Type type, constraints::ConstraintSystem& cs,
+                                Optional<Pattern*> typeFromPattern) {
+    // Attempt to solve the constraint system.
+    SmallVector<Solution, 4> viable;
+    if ((cs.solve(expr, viable) || viable.size() != 1) &&
+        cs.salvage(viable, expr)) {
+        return true;
+    }
+    
+    auto &solution = viable[0];
+    if (getLangOpts().DebugConstraintSolver) {
+        auto &log = Context.TypeCheckerDebug->getStream();
+        log << "---Solution---\n";
+        solution.dump(log);
+    }
+    
+    cs.cacheExprTypes(expr);
+    
+    // Perform the conversion.
+    Expr *result = solution.coerceToType(expr, type,
+                                         cs.getConstraintLocator(expr),
+                                         /*ignoreTopLevelInjection*/false,
+                                         typeFromPattern);
+    if (!result) {
+        return true;
+    }
+    
+    cs.setExprTypes(expr);
+    
+    if (getLangOpts().DebugConstraintSolver) {
+        auto &log = Context.TypeCheckerDebug->getStream();
+        log << "---Type-checked expression---\n";
+        result->dump(log);
+        log << "\n";
+    }
+    
+    expr = result;
+    return false;
+}
+
 bool TypeChecker::convertToType(Expr *&expr, Type type, DeclContext *dc,
                                 Optional<Pattern*> typeFromPattern) {
   // TODO: need to add kind arg?
   // Construct a constraint system from this expression.
   ConstraintSystem cs(*this, dc, ConstraintSystemFlags::AllowFixes);
-  
-  // We need to walk through the expression to set the type variables.
-  cs.generateConstraints(expr);
 
   // If there is a type that we're expected to convert to, add the conversion
   // constraint.
   cs.addConstraint(ConstraintKind::Conversion, expr->getType(), type,
                    cs.getConstraintLocator(expr));
-
-  if (getLangOpts().DebugConstraintSolver) {
-    auto &log = Context.TypeCheckerDebug->getStream();
-    log << "---Initial constraints for the given expression---\n";
-    expr->dump(log);
-    log << "\n";
-    cs.print(log);
-  }
-
-  // Attempt to solve the constraint system.
-  SmallVector<Solution, 4> viable;
-  if ((cs.solve(expr, viable) || viable.size() != 1) &&
-      cs.salvage(viable, expr)) {
-    return true;
-  }
-
-  auto &solution = viable[0];
-  if (getLangOpts().DebugConstraintSolver) {
-    auto &log = Context.TypeCheckerDebug->getStream();
-    log << "---Solution---\n";
-    solution.dump(log);
-  }
-
-  cs.cacheExprTypes(expr);
-
-  // Perform the conversion.
-  Expr *result = solution.coerceToType(expr, type,
-                                       cs.getConstraintLocator(expr),
-                                       /*ignoreTopLevelInjection*/false,
-                                       typeFromPattern);
-  if (!result) {
-    return true;
-  }
-
-  cs.setExprTypes(expr);
-
+    
   if (getLangOpts().DebugConstraintSolver) {
-    auto &log = Context.TypeCheckerDebug->getStream();
-    log << "---Type-checked expression---\n";
-    result->dump(log);
-    log << "\n";
+        auto &log = Context.TypeCheckerDebug->getStream();
+        log << "---Initial constraints for the given expression---\n";
+        expr->dump(log);
+        log << "\n";
+        cs.print(log);
   }
-
-  expr = result;
-  return false;
+    
+  return convertToType(expr, type, cs, typeFromPattern);
 }
 
 //===----------------------------------------------------------------------===//

branches/rxwei-patch-1/lib/Sema/TypeChecker.h

@@ -1550,6 +1550,16 @@ class TypeChecker final : public LazyResolver {
   bool convertToType(Expr *&expr, Type type, DeclContext *dc,
                      Optional<Pattern*> typeFromPattern = None);
 
+  /// Convert the given expression to the given type.
+  ///
+  /// \param expr The expression, which will be updated in place.
+  /// \param type The type to convert to.
+  /// \param cs The constraint system that will be used to the conversion.
+  ///
+  /// \returns true if an error occurred, false otherwise.
+  bool convertToType(Expr *&expr, Type type, constraints::ConstraintSystem& cs,
+                     Optional<Pattern*> typeFromPattern = None);
+    
   /// Coerce the given expression to materializable type, if it
   /// isn't already.
   Expr *coerceToRValue(Expr *expr,