[clang] Improve diagnostics for auto-return-type function if the return expr had an error

[hokein]

Summary

Given the following case:

auto k() {
  return undef();
  return 1;
}

Prior to the patch, clang emits an `cannot initialize return object of type
'auto' with an rvalue of type 'int'` diagnostic on the second return
(because the return type of the function cannot be deduced from the first contain-errors return).

This patch suppresses this error.

[hokein]

context: this would fix an issue in https://reviews.llvm.org/D82284.

[sammccall]

This approach isn't the most obvious one, to me.
In the test, the lambda is invalid with auto return type, where it seems that valid with int return type and a body that contains-errors would be better.

I'm guessing this comes down to what fits most naturally in the implementation? (If you skip return statements with broken types, you need to distinguish between void lambdas and broken ones somehow).
Anyway, this decision/motivation probably also deserves a comment.

clang/lib/Sema/SemaStmt.cpp

3306

This seems to only handle lambdas (and blocks).
Is there a corresponding fix needed for C++14 auto x() { ... } ?

3331

This deserves a comment, like:

// If we've already decided this lambda is invalid, e.g. because
// we saw a `return` whose expression had an error, don't keep
// trying to deduce its return type.

[hokein]

address comments and add the missing fix for C++14 auto func.

clang/lib/Sema/SemaStmt.cpp

3306

oh, right, thanks! The C++14 auo function is in a separate code path, fixed.

[sammccall]

Great stuff, thank you!

clang/lib/Sema/SemaStmt.cpp

const FunctionProtoType *FPT =
       FD->getTypeSourceInfo()->getType()->castAs<FunctionProtoType>();
   return FPT->getReturnType()->isUndeducedType();
 }
 
 /// ActOnCapScopeReturnStmt - Utility routine to type-check return statements
 /// for capturing scopes.
 ///
 StmtResult
 Sema::ActOnCapScopeReturnStmt(SourceLocation ReturnLoc, Expr *RetValExp) {
   // If this is the first return we've seen, infer the return type.
   // [expr.prim.lambda]p4 in C++11; block literals follow the same rules.
   CapturingScopeInfo *CurCap = cast<CapturingScopeInfo>(getCurFunction());
   QualType FnRetType = CurCap->ReturnType;
   LambdaScopeInfo *CurLambda = dyn_cast<LambdaScopeInfo>(CurCap);
   bool HasDeducedReturnType =
       CurLambda && hasDeducedReturnType(CurLambda->CallOperator);
 
   if (ExprEvalContexts.back().Context ==
           ExpressionEvaluationContext::DiscardedStatement &&
       (HasDeducedReturnType || CurCap->HasImplicitReturnType)) {
     if (RetValExp) {
       ExprResult ER =
           ActOnFinishFullExpr(RetValExp, ReturnLoc, /*DiscardedValue*/ false);
       if (ER.isInvalid())
         return StmtError();
       RetValExp = ER.get();
     }
     return ReturnStmt::Create(Context, ReturnLoc, RetValExp,
                               /* NRVOCandidate=*/nullptr);
   }
 
   if (HasDeducedReturnType) {
+    FunctionDecl *FD = CurLambda->CallOperator;
+    if (FD->isInvalidDecl())
+      return StmtError();
     // In C++1y, the return type may involve 'auto'.
     // FIXME: Blocks might have a return type of 'auto' explicitly specified.
-    FunctionDecl *FD = CurLambda->CallOperator;
     if (CurCap->ReturnType.isNull())
       CurCap->ReturnType = FD->getReturnType();
 
     AutoType *AT = CurCap->ReturnType->getContainedAutoType();
     assert(AT && "lost auto type from lambda return type");
     if (DeduceFunctionTypeFromReturnExpr(FD, ReturnLoc, RetValExp, AT)) {
       FD->setInvalidDecl();
       // FIXME: preserve the ill-formed return expression.

clang/test/SemaCXX/lambda-expressions.cpp

 // rdar://22032373
 namespace rdar22032373 {
 void foo() {
   auto blk = [](bool b) {
     if (b)
       return undeclared_error; // expected-error {{use of undeclared identifier}}
     return 0;
   };
+  auto bar = []() {
+    return undef(); // expected-error {{use of undeclared identifier}}
+    return 0; // verify no init_conversion_failed diagnostic emitted.
+  };
 }
 }
 
 namespace nested_lambda {
 template <int N>
 class S {};
 
 void foo() {