[AST][RecoveryExpr] Make DeduceAutoType fail if the auto is deduced from recovery exprs.

[hokein]

Summary

With recovery-ast, we will get an undeduced auto return type for
"auto foo()->undef()" function declaration, the function decl still keeps
valid, it is dangerous, and breaks assumptions in clang, and leads crashes.

This patch invalidates these functions, if we deduce autos from the
return rexpression, which is similar to auto VarDecl.

[hokein]

small update

[hokein]

clang/test/AST/ast-dump-recovery.cpp

182

with this patch, we don't preserve the return stmt, so we only have the CXXRecordDecl for the lambda, and no TypeAliasDecl node.

[hokein]

Friendly ping, in case it is out of your radar -- this fixes another recovery-ast crash-on-invalid.

[sammccall]

clang/lib/Sema/SemaTemplateDeduction.cpp

4658

it's not clear to me what "if the type is known" means precisely.
If it's just a matter of checking some condition and continuing, presumably we'd do that already. as is, the FIXME doesn't seem actionable.

clang/test/AST/ast-dump-invalid-auto-return-funcs.cpp

4

maybe add a comment/FIXME about why we're finding int as the return type?

[hokein]

address comments.

clang/lib/Sema/SemaStmt.cpp

if (HasDeducedReturnType) {
     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.
       return StmtError();
     }
     CurCap->ReturnType = FnRetType = FD->getReturnType();
   } else if (CurCap->HasImplicitReturnType) {
     // For blocks/lambdas with implicit return types, we check each return
     // statement individually, and deduce the common return type when the block
     // or lambda is completed.
     // FIXME: Fold this into the 'auto' codepath above.

clang/lib/Sema/SemaTemplateDeduction.cpp

 ///        'auto' template parameters. The value specified is the template
 ///        parameter depth at which we should perform 'auto' deduction.
 /// \param IgnoreConstraints Set if we should not fail if the deduced type does
 ///                          not satisfy the type-constraint in the auto type.
 Sema::DeduceAutoResult
 Sema::DeduceAutoType(TypeLoc Type, Expr *&Init, QualType &Result,
                      Optional<unsigned> DependentDeductionDepth,
                      bool IgnoreConstraints) {
+  if (Init->containsErrors())
+    return DAR_FailedAlreadyDiagnosed;
   if (Init->getType()->isNonOverloadPlaceholderType()) {
     ExprResult NonPlaceholder = CheckPlaceholderExpr(Init);
     if (NonPlaceholder.isInvalid())
       return DAR_FailedAlreadyDiagnosed;
     Init = NonPlaceholder.get();
   }
 
   DependentAuto DependentResult = {

clang/test/AST/ast-dump-invalid-auto-return-funcs.cpp

+// RUN: not %clang_cc1 -triple x86_64-unknown-unknown -Wno-unused-value -fcxx-exceptions -frecovery-ast -std=gnu++17 -ast-dump %s | FileCheck -strict-whitespace %s
+
+// CHECK: FunctionDecl {{.*}} s1 'auto ()'
+auto s1(); // valid
+// FIXME: why we're finding int as the return type. int is used as a fallback type?
+// CHECK: FunctionDecl {{.*}} invalid s2 'auto () -> int'
+auto s2() -> undef();
+// CHECK: FunctionDecl {{.*}} invalid s3 'auto () -> int'
+auto s3() -> decltype(undef());
+// CHECK: FunctionDecl {{.*}} invalid s4 'auto ()'
+auto s4() {
+  return undef();
+}
+// CHECK: FunctionDecl {{.*}} s5 'void ()'
+auto s5() {} // valid, no return stmt, fallback to void
+
+class Foo {
+  // CHECK: CXXMethodDecl {{.*}} foo1 'auto ()'
+  auto foo1(); // valid
+  // CHECK: CXXMethodDecl {{.*}} invalid foo2 'auto () -> int'
+  auto foo2() -> undef();
+  // CHECK: CXXMethodDecl {{.*}} invalid foo3 'auto () -> int'
+  auto foo3() -> decltype(undef());
+  // CHECK: CXXMethodDecl {{.*}} invalid foo4 'auto ()'
+  auto foo4() { return undef(); }
+  // CHECK: CXXMethodDecl {{.*}} foo5 'void ()'
+  auto foo5() {} // valid, no return stmt, fallback to void.
+};

clang/test/AST/ast-dump-recovery.cpp

void InitializerForAuto() {
 
   decltype(ned);
   // very bad initailizer: there is an unresolved typo expr internally, we just
   // drop it.
   // CHECK: `-VarDecl {{.*}} invalid unresolved_typo 'auto'
   auto unresolved_typo = gned.*[] {};
 }
 
-// CHECK:      `-TypeAliasDecl {{.*}} Escape 'decltype([] {
-// CHECK-NEXT:   return <recovery-expr>(undef);
-// CHECK-NEXT: }())'
-// CHECK-NEXT:   `-DecltypeType {{.*}} 'decltype([] {
-// CHECK-NEXT:     return <recovery-expr>(undef);
-// CHECK-NEXT:   }())' dependent
+// Verified that the generated call operator is invalid.
+// CHECK: |-CXXMethodDecl {{.*}} invalid operator() 'auto () const -> auto'
 using Escape = decltype([] { return undef(); }());

clang/test/Sema/invalid-bitwidth-expr.mm

 // RUN: %clang_cc1 -fobjc-runtime=gcc -frecovery-ast -verify %s
-// RUN: %clang_cc1 -fobjc-runtime=gcc -fno-recovery-ast -verify %s
 
 @interface Ivar
 {
   int Foo : foo(); // expected-error {{use of undeclared identifier}}
 };
 @end
 
 struct X { int Y: foo(); }; // expected-error {{use of undeclared identifier}}
 
 constexpr int s = sizeof(Ivar);
 constexpr int ss = sizeof(X);
+
+auto func() {
+  return undef(); // expected-error {{use of undeclared identifier}}
+}
+struct Y {
+  int X : func();
+};
+constexpr int sss = sizeof(Y);