xxx

Author: hamishknight

lib/AST/ASTScopeCreation.cpp

@@ -959,11 +959,8 @@ AnnotatedInsertionPoint
 ConditionalClausePatternUseScope::expandAScopeThatCreatesANewInsertionPoint(
     ScopeCreator &scopeCreator) {
   auto *initializer = sec.getInitializer();
-  if (!isa<ErrorExpr>(initializer)) {
-    scopeCreator
-      .constructExpandAndInsert<ConditionalClauseInitializerScope>(
-        this, initializer);
-    }
+  scopeCreator.constructExpandAndInsert<ConditionalClauseInitializerScope>(
+      this, initializer);
 
   return {this,
           "Succeeding code must be in scope of conditional clause pattern bindings"};

lib/Sema/CSGen.cpp

@@ -3155,6 +3155,10 @@ namespace {
       case PatternKind::Expr: {
         // We generate constraints for ExprPatterns in a separate pass. For
         // now, just create a type variable.
+        auto *EP = cast<ExprPattern>(pattern);
+        EP->getSubExpr()->forEachUnresolvedVariable([&](VarDecl *VD) {
+          CS.setType(VD, ErrorType::get(CS.getASTContext()));
+        });
         return setType(CS.createTypeVariable(CS.getConstraintLocator(locator),
                                              TVO_CanBindToNoEscape));
       }

lib/Sema/TypeCheckConstraints.cpp

@@ -855,7 +855,7 @@ bool TypeChecker::typeCheckBinding(Pattern *&pattern, Expr *&initializer,
       // FIXME: We shouldn't be leaving AST un-type-checked in invalid cases, we
       // ought to fix that and then change this to only consider IDE inspection.
       auto &ctx = CE->getASTContext();
-      if (ctx.hadError() || ctx.SourceMgr.hasIDEInspectionTargetBuffer()) {
+      if (ctx.SourceMgr.hasIDEInspectionTargetBuffer()) {
         target.markInvalid();
         return true;
       }

lib/Sema/TypeCheckStmt.cpp

@@ -1092,12 +1092,14 @@ class StmtChecker : public StmtVisitor<StmtChecker, Stmt*> {
     auto &eval = getASTContext().evaluator;
     auto *S =
         evaluateOrDefault(eval, PreCheckReturnStmtRequest{RS, DC}, nullptr);
+    if (!S)
+      return nullptr;
 
     // We do a cast here as it may have been turned into a FailStmt. We should
     // return that without doing anything else.
-    RS = dyn_cast_or_null<ReturnStmt>(S);
+    RS = dyn_cast<ReturnStmt>(S);
     if (!RS)
-      return S;
+      return visit(S);
 
     auto TheFunc = AnyFunctionRef::fromDeclContext(DC);
     assert(TheFunc && "Should have bailed from pre-check if this is None");
@@ -1778,16 +1780,26 @@ Stmt *PreCheckReturnStmtRequest::evaluate(Evaluator &evaluator, ReturnStmt *RS,
   auto &ctx = DC->getASTContext();
   auto fn = AnyFunctionRef::fromDeclContext(DC);
 
+  auto errorResult = [&]() -> Stmt * {
+    if (RS->hasResult()) {
+      auto *AE = new (ctx)
+          AssignExpr(new (ctx) DiscardAssignmentExpr(SourceLoc(), true),
+                     SourceLoc(), RS->getResult(), true);
+      return BraceStmt::createImplicit(ctx, {AE});
+    }
+    return nullptr;
+  };
+
   // Not valid outside of a function.
   if (!fn) {
     ctx.Diags.diagnose(RS->getReturnLoc(), diag::return_invalid_outside_func);
-    return nullptr;
+    return errorResult();
   }
 
   // If the return is in a defer, then it isn't valid either.
   if (isDefer(DC)) {
     ctx.Diags.diagnose(RS->getReturnLoc(), diag::jump_out_of_defer, "return");
-    return nullptr;
+    return errorResult();
   }
 
   // The rest of the checks only concern return statements with results.