Fix Bug 23189 in C++14 type inference for lambdas with undeclared identifiers

[tdudziak]

Summary

Fixes Bug 23189 by adding additional checks in DeduceFunctionTypeFromReturnExpr.

Without these checks, the code attempts to dereference a null pointer when trying to infer the return type of a lambda if there are multiple return statements and one of them contains an expression with an undeclared identifier.

[dim]

It looks good to me, and it fixes both the original test case in bug 23189, and the reduced test case I added there.

[rsmith]

Kaelyn, should we do typo correction sooner here?

[rsmith]

lib/Sema/SemaStmt.cpp

2983–2989

Dependent types are supposed to be eliminated by this check. I think the right thing to do is to correct typos in the expression before we get to this point.

lib/Sema/SemaStmt.cpp

if (RetExpr && isa<InitListExpr>(RetExpr)) {
     //  a braced-init-list, the program is ill-formed.
     Diag(RetExpr->getExprLoc(),
          getCurLambda() ? diag::err_lambda_return_init_list
                         : diag::err_auto_fn_return_init_list)
         << RetExpr->getSourceRange();
     return true;
   }
 
   if (FD->isDependentContext()) {
     // C++1y [dcl.spec.auto]p12:
     //   Return type deduction [...] occurs when the definition is
     //   instantiated even if the function body contains a return
     //   statement with a non-type-dependent operand.
     assert(AT->isDeduced() && "should have deduced to dependent type");
     return false;
   } else if (RetExpr) {
     //  If the deduction is for a return statement and the initializer is
     //  a braced-init-list, the program is ill-formed.
     if (isa<InitListExpr>(RetExpr)) {
       Diag(RetExpr->getExprLoc(), diag::err_auto_fn_return_init_list);
       return true;
     }
 
if (FD->isDependentContext()) {
     if (Deduced.isNull())
       return true;
   }
 
   //  If a function with a declared return type that contains a placeholder type
   //  has multiple return statements, the return type is deduced for each return
   //  statement. [...] if the type deduced is not the same in each deduction,
   //  the program is ill-formed.
-  if (AT->isDeduced() && !FD->isInvalidDecl()) {
+  if (AT->isDeduced() && !AT->isDependentType() && !FD->isInvalidDecl()) {
     AutoType *NewAT = Deduced->getContainedAutoType();
     if (!FD->isDependentContext() &&
+        !NewAT->isDependentType() &&
         !Context.hasSameType(AT->getDeducedType(), NewAT->getDeducedType())) {
       const LambdaScopeInfo *LambdaSI = getCurLambda();
       if (LambdaSI && LambdaSI->HasImplicitReturnType) {
         Diag(ReturnLoc, diag::err_typecheck_missing_return_type_incompatible)
           << NewAT->getDeducedType() << AT->getDeducedType()
           << true /*IsLambda*/;
       } else {
         Diag(ReturnLoc, diag::err_auto_fn_different_deductions)

test/SemaCXX/cxx14-auto-lambda-bad-return-1.cpp

+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
+
+// First return triggers and error, the type of the second return is known
+// (void). Type inference will try to reconcile these types and can get
+// confused while doing so (bug 23189).
+
+void test() {
+    auto a = [] {
+        return b; // expected-error {{use of undeclared identifier 'b'}}
+        return;
+    };
+}

test/SemaCXX/cxx14-auto-lambda-bad-return-2.cpp

+// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify %s
+
+// First return is properly typed (void) but the second one triggers an error.
+// Type inference might still try to deduce the type of this lambda and can
+// get confused while doing so (bug 23189).
+
+void test() {
+    auto a = [] {
+        return;
+        return &b; // expected-error {{use of undeclared identifier 'b'}}
+    };
+}