[Type checker] Make coercePatternToType return the new Pattern.

Rather than mutating the parameter pattern in place and separately
return whether an error occurred, return the new pattern or NULL if an
error occurred. While here, switch over to ContextualPattern for the
input.

And get rid of that infernal "goto".

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -2259,6 +2259,7 @@ namespace {
       // or exhaustive catches.
       class FindInnerThrows : public ASTWalker {
         ConstraintSystem &CS;
+        DeclContext *DC;
         bool FoundThrow = false;
 
         std::pair<bool, Expr *> walkToExprPre(Expr *expr) override {
@@ -2344,12 +2345,12 @@ namespace {
           Type exnType = CS.getASTContext().getErrorDecl()->getDeclaredType();
           if (!exnType)
             return false;
-          if (TypeChecker::coercePatternToType(pattern,
-                                        TypeResolution::forContextual(CS.DC),
-                                        exnType,
-                                        TypeResolverContext::InExpression)) {
+          auto contextualPattern =
+              ContextualPattern::forRawPattern(pattern, DC);
+          pattern = TypeChecker::coercePatternToType(
+            contextualPattern, exnType, TypeResolverContext::InExpression);
+          if (!pattern)
             return false;
-          }
 
           clause->setErrorPattern(pattern);
           return clause->isSyntacticallyExhaustive();
@@ -2385,7 +2386,8 @@ namespace {
         }
 
       public:
-        FindInnerThrows(ConstraintSystem &cs) : CS(cs) {}
+        FindInnerThrows(ConstraintSystem &cs, DeclContext *dc)
+            : CS(cs), DC(dc) {}
 
         bool foundThrow() { return FoundThrow; }
       };
@@ -2398,7 +2400,7 @@ namespace {
       if (!body)
         return false;
 
-      auto tryFinder = FindInnerThrows(CS);
+      auto tryFinder = FindInnerThrows(CS, expr);
       body->walk(tryFinder);
       return tryFinder.foundThrow();
     }

lib/Sema/TypeCheckConstraints.cpp

@@ -2801,8 +2801,6 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
         ? TypeResolverContext::EditorPlaceholderExpr
         : TypeResolverContext::InExpression;
     options |= TypeResolutionFlags::OverrideType;
-    options |= TypeResolutionFlags::AllowUnspecifiedTypes;
-    options |= TypeResolutionFlags::AllowUnboundGenerics;
 
     // FIXME: initTy should be the same as resultTy; now that typeCheckExpression()
     // returns a Type and not bool, we should be able to simplify the listener
@@ -2812,8 +2810,12 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
       return true;
 
     // Apply the solution to the pattern as well.
-    if (coercePatternToType(pattern, TypeResolution::forContextual(DC), initTy,
-                            options, TypeLoc())) {
+    auto contextualPattern =
+        ContextualPattern::forRawPattern(pattern, DC);
+    if (auto coercedPattern = TypeChecker::coercePatternToType(
+            contextualPattern, initTy, options)) {
+      pattern = coercedPattern;
+    } else {
       return true;
     }
   }
@@ -3063,13 +3065,11 @@ bool TypeChecker::typeCheckForEachBinding(DeclContext *dc, ForEachStmt *stmt) {
       Pattern *pattern = Stmt->getPattern();
       TypeResolutionOptions options(TypeResolverContext::ForEachStmt);
       options |= TypeResolutionFlags::OverrideType;
-      options |= TypeResolutionFlags::AllowUnboundGenerics;
-      options |= TypeResolutionFlags::AllowUnspecifiedTypes;
-      if (TypeChecker::coercePatternToType(pattern,
-                                           TypeResolution::forContextual(DC),
-                                           InitType, options)) {
+      auto contextualPattern = ContextualPattern::forRawPattern(pattern, DC);
+      pattern = TypeChecker::coercePatternToType(contextualPattern,
+                                                 InitType, options);
+      if (!pattern)
         return nullptr;
-      }
       Stmt->setPattern(pattern);
 
       // Get the conformance of the sequence type to the Sequence protocol.
@@ -3189,6 +3189,7 @@ bool TypeChecker::typeCheckStmtCondition(StmtCondition &cond, DeclContext *dc,
       hadAnyFalsable = true;
       continue;
     }
+    assert(elt.getKind() != StmtConditionElement::CK_Boolean);
 
     // This is cleanup goop run on the various paths where type checking of the
     // pattern binding fails.