[constexpr][c++2a] Try-catch blocks in constexpr functions

[bruno]

Summary

Implement support for try-catch blocks in constexpr functions, as
proposed in http://wg21.link/P1002 and voted in San Diego for c++20.

The idea is that we can still never throw inside constexpr, so the catch
block is never entered. A try-catch block like this:

try { f(); } catch (...) { }

is then morally equivalent to just

{ f(); }

Same idea should apply for function/constructor try blocks.

rdar://problem/45530773

[rsmith]

lib/AST/ExprConstant.cpp

4278–4287

The children of a try statement are the try body followed by the catch statements, in order. We only want to evaluate the normal body, so you should just recurse to evaluating cast<CXXTryStmt>(S)->getTryBlock()...

4290–4294

... and this should then be unreachable.

lib/Sema/SemaDeclCXX.cpp

1904–1905

Is there a reason to not allow this as an extension in earlier language modes?

1906–1907

Cxx1yLoc isn't right here; we should produce a -Wc++17-compat diagnostic, not a -Wc++14-compat diagnostic. We should probably prefer the Cxx1zLoc warning over the Cxx1yLoc warning if we have both.

1915–1922

We should just unconditionally allow CXXCatchStmts (that is, don't bother checking the language mode, just walk the children), since whenever we encounter one we must also have a CXXTryStmt, which we'll already have checked.

1962–1983

The repetition can be avoided here by walking the children of Body (regardless of what kind of statement it is), and checking them all. (We can't *quite* just pass Body directly to CheckConstexprFunctionStmt because (nested) compound statements aren't permitted until C++14.)

1973

Don't return here: we still need to do the other checks below.

[bruno]

Address @rsmith comments

[erik.pilkington]

Hi Bruno, thanks for working on this!

include/clang/Basic/DiagnosticSemaKinds.td

2370 ↗

(On Diff #176559)

I guess this should technically be C++2a

2431 ↗

(On Diff #176559)

(ditto)

lib/Sema/SemaDeclCXX.cpp

1913–1916

I think we still need to check out the catch stmt (even if it'll never be evaluated) to make sure that it doesn't have any prohibited statements. i.e., we should error here:

constexpr int f() { 
  try { return 0; }
  catch (...) {
    merp: goto merp;
  }
}

But I believe that this patch will accept this.

[bruno]

Update patch after @erik.pilkington review!

[erik.pilkington]

LGTM, but you should probably let @rsmith have the final word!

lib/Sema/SemaDeclCXX.cpp

1916–1919

Might be clearer to just write if (!CheckConstexprFunctionStmt(SemaRef, Dcl, cast<CXXCatchStmt>(SubStmt)->getHandlerBlock())), rather than looping over 1 statement. Could you also add that example I posted as a testcase for this?

[aaron.ballman]

Some minor nits from the peanut gallery.

lib/AST/ExprConstant.cpp

4278

Missing full stop.

lib/Sema/SemaDeclCXX.cpp

1906

I'd appreciate curly braces here, even though they're not strictly required by the coding standard. ;-)

1985

Likewise here.

[bruno]

Address @aaron.ballman and @erik.pilkington reviews.

[aaron.ballman]

LGTM aside from a few other small nits.

lib/Sema/SemaDeclCXX.cpp

1904

Cxx2aLoc.isInvalid()

1956

This restriction is lifted in C++2a, as long as inner statements also apply the general constexpr rules.

lib/AST/ExprConstant.cpp

case Stmt::AttributedStmtClass:
     // As a general principle, C++11 attributes can be ignored without
     // any semantic impact.
     return EvaluateStmt(Result, Info, cast<AttributedStmt>(S)->getSubStmt(),
                         Case);
 
   case Stmt::CaseStmtClass:
   case Stmt::DefaultStmtClass:
     return EvaluateStmt(Result, Info, cast<SwitchCase>(S)->getSubStmt(), Case);
+  case Stmt::CXXTryStmtClass: {
+    // Evaluate try blocks by evaluating all sub statements and keep track
+    // whether there's a return.
+    EvalStmtResult ESR = ESR_Succeeded;
+    for (const Stmt *SubStmt : S->children()) {
+      EvalStmtResult SubStmtESR = EvaluateStmt(Result, Info, SubStmt, Case);
+      if (SubStmtESR != ESR_Succeeded && SubStmtESR != ESR_Returned)
+        return ESR_Failed;
+      if (SubStmtESR == ESR_Returned)
+        ESR = SubStmtESR;
+    }
+    return ESR;
+  }
+  case Stmt::CXXCatchStmtClass:
+    // No need to evaluate catch since it will be ignored in case the try block
+    // is successfully evaluated.
+    return ESR_Succeeded;
   }
 }
 
 /// CheckTrivialDefaultConstructor - Check whether a constructor is a trivial
 /// default constructor. If so, we'll fold it whether or not it's marked as
 /// constexpr. If it is marked as constexpr, we will never implicitly define it,
 /// so we need special handling.
 static bool CheckTrivialDefaultConstructor(EvalInfo &Info, SourceLocation Loc,
                                            const CXXConstructorDecl *CD,

lib/Sema/SemaDeclCXX.cpp

if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
     for (Stmt *SubStmt : S->children())
       if (SubStmt &&
           !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
                                       Cxx1yLoc))
         return false;
     return true;
 
+  case Stmt::CXXTryStmtClass:
+    if (!SemaRef.getLangOpts().CPlusPlus2a)
+      break;
+    if (!Cxx1yLoc.isValid())
+      Cxx1yLoc = S->getBeginLoc();
+    for (Stmt *SubStmt : S->children())
+      if (SubStmt &&
+          !CheckConstexprFunctionStmt(SemaRef, Dcl, SubStmt, ReturnStmts,
+                                      Cxx1yLoc))
+        return false;
+    return true;
+
+  case Stmt::CXXCatchStmtClass:
+    if (!SemaRef.getLangOpts().CPlusPlus2a)
+      break;
+    if (!Cxx1yLoc.isValid())
+      Cxx1yLoc = S->getBeginLoc();
+    // In case we got a valid constexpr try block, the catch block can be
+    // ignored since it will never be evaluated in a constexpr context.
+    return true;
+
   default:
     if (!isa<Expr>(S))
       break;
 
     // C++1y allows expression-statements.
     if (!Cxx1yLoc.isValid())
       Cxx1yLoc = S->getBeginLoc();
     return true;
   }
 
   SemaRef.Diag(S->getBeginLoc(), diag::err_constexpr_body_invalid_stmt)
       << isa<CXXConstructorDecl>(Dcl);
   return false;
 }
 
 /// Check the body for the given constexpr function declaration only contains
 /// the permitted types of statement. C++11 [dcl.constexpr]p3,p4.
 ///
 /// \return true if the body is OK, false if we have diagnosed a problem.
 bool Sema::CheckConstexprFunctionBody(const FunctionDecl *Dcl, Stmt *Body) {
+  SmallVector<SourceLocation, 4> ReturnStmts;
+
   if (isa<CXXTryStmt>(Body)) {
     // C++11 [dcl.constexpr]p3:
     //  The definition of a constexpr function shall satisfy the following
     //  constraints: [...]
     // - its function-body shall be = delete, = default, or a
     //   compound-statement
     //
     // C++11 [dcl.constexpr]p4:
     //  In the definition of a constexpr constructor, [...]
     // - its function-body shall not be a function-try-block;
+    if (!getLangOpts().CPlusPlus2a) {
       Diag(Body->getBeginLoc(), diag::err_constexpr_function_try_block)
           << isa<CXXConstructorDecl>(Dcl);
       return false;
     }
 
-  SmallVector<SourceLocation, 4> ReturnStmts;
+    // constexpr function try blocks are allowed in c++2a, assuming that the
+    // inner statements do also apply to general constexpr rules.
+    SourceLocation Cxx1yLoc;
+    for (Stmt *SubStmt : Body->children())
+      if (SubStmt &&
+          !CheckConstexprFunctionStmt(*this, Dcl, SubStmt, ReturnStmts,
+                                      Cxx1yLoc))
+        return false;
+    if (Cxx1yLoc.isValid())
+      Diag(Cxx1yLoc, diag::warn_cxx11_compat_constexpr_body_invalid_stmt)
+          << isa<CXXConstructorDecl>(Dcl);
+    return true;
+  }
 
   // - its function-body shall be [...] a compound-statement that contains only
   //   [... list of cases ...]
   CompoundStmt *CompBody = cast<CompoundStmt>(Body);
   SourceLocation Cxx1yLoc;
   for (auto *BodyIt : CompBody->body()) {
     if (!CheckConstexprFunctionStmt(*this, Dcl, BodyIt, ReturnStmts, Cxx1yLoc))
       return false;
   }
 
   if (Cxx1yLoc.isValid())
     Diag(Cxx1yLoc,
          getLangOpts().CPlusPlus14
            ? diag::warn_cxx11_compat_constexpr_body_invalid_stmt
            : diag::ext_constexpr_body_invalid_stmt)
       << isa<CXXConstructorDecl>(Dcl);
 
   if (const CXXConstructorDecl *Constructor
         = dyn_cast<CXXConstructorDecl>(Dcl)) {

test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p3.cpp

 // RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++11 -Werror=c++1y-extensions %s
 // RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++1y -DCXX1Y %s
+// RUN: %clang_cc1 -verify -fcxx-exceptions -triple=x86_64-linux-gnu -std=c++2a -DCXX1Y -DCXX2A %s
 
 namespace N {
   typedef char C;
 }
 
 namespace M {
   typedef double D;
 }

 constexpr int T::OutOfLineVirtual() const { return 0; }
 #ifdef CXX1Y
 struct T2 {
   int n = 0;
   constexpr T2 &operator=(const T2&) = default; // ok
 };
 struct T3 {
   constexpr T3 &operator=(const T3&) const = default;
-  // expected-error@-1 {{an explicitly-defaulted copy assignment operator may not have 'const' or 'volatile' qualifiers}}
+#ifndef CXX2A
+  // expected-error@-2 {{an explicitly-defaulted copy assignment operator may not have 'const' or 'volatile' qualifiers}}
+#else
+  // expected-warning@-4 {{explicitly defaulted copy assignment operator is implicitly deleted}}
+  // expected-note@-5 {{function is implicitly deleted because its declared type does not match the type of an implicit copy assignment operator}}
+#endif
 };
 #endif
 struct U {
   constexpr U SelfReturn() const;
   constexpr int SelfParam(U) const;
 };
 
 struct V : virtual U { // expected-note {{here}}

 constexpr int DisallowedStmtsCXX1Y_2() {
   //  - a goto statement
   goto x; // expected-error {{statement not allowed in constexpr function}}
 x:
   return 0;
 }
 constexpr int DisallowedStmtsCXX1Y_3() {
   //  - a try-block,
-  try {} catch (...) {} // expected-error {{statement not allowed in constexpr function}}
+  try {} catch (...) {}
+#ifndef CXX2A
+  // expected-error@-2 {{statement not allowed in constexpr function}}
+#endif
   return 0;
 }
 constexpr int DisallowedStmtsCXX1Y_4() {
   //  - a definition of a variable of non-literal type
   NonLiteral nl; // expected-error {{variable of non-literal type 'NonLiteral' cannot be defined in a constexpr function}}
   return 0;
 }
 constexpr int DisallowedStmtsCXX1Y_5() {

test/CXX/dcl.dcl/dcl.spec/dcl.constexpr/p4.cpp

 // RUN: %clang_cc1 -verify -std=c++11 -fcxx-exceptions -Werror=c++1y-extensions %s
 // RUN: %clang_cc1 -verify -std=c++1y -fcxx-exceptions -DCXX1Y %s
+// RUN: %clang_cc1 -verify -std=c++2a -fcxx-exceptions -DCXX1Y -DCXX2A %s
 
 namespace N {
   typedef char C;
 }
 
 namespace M {
   typedef double D;
 }
namespace IndirectVBase {
   public:
     constexpr C() {} // expected-error {{constexpr constructor not allowed in class with virtual base class}}
   };
 }
 
 // - its function-body shall not be a function-try-block;
 struct U {
   constexpr U()
-    try // expected-error {{function try block not allowed in constexpr constructor}}
+    try
+#ifndef CXX2A
+    // expected-error@-2 {{function try block not allowed in constexpr constructor}}
+#endif
     : u() {
   } catch (...) {
     throw;
   }
   int u;
 };
 
 // - the compound-statememt of its function-body shall contain only

test/CXX/drs/dr6xx.cpp

struct B : X {
     constexpr void f() const {} // expected-error {{virtual function cannot be constexpr}}
   };
 
   struct NonLiteral { NonLiteral() {} }; // expected-note {{not an aggregate and has no constexpr constructors}}
 
   struct C {
     constexpr C(NonLiteral);
     constexpr C(NonLiteral, int) {} // expected-error {{not a literal type}}
-    constexpr C() try {} catch (...) {} // expected-error {{function try block}}
+    constexpr C() try {} catch (...) {}
+#if __cplusplus <= 201703L
+    // expected-error@-2 {{function try block}}
+#endif
   };
 
   struct D {
     operator int() const;
     constexpr D(int) {}
     D(float); // expected-note 2{{declared here}}
   };
   constexpr int get();

www/cxx_status.html

</tr>
     <tr>
       <td>Destroying operator delete</td>
       <td><a href="http://wg21.link/p0722r3">P0722R3</a></td>
       <td class="full" align="center">Clang 6</td>
     </tr>
     <tr>
       <td rowspan=4>Relaxations of <tt>constexpr</tt> restrictions</td>
       <td><a href="http://wg21.link/p1064r0">P1064R0</a></td>
-      <td rowspan=4 class="none" align="center">No</td>
+      <td class="none" align="center">No</td>
     </tr>
       <tr> <!-- from San Diego -->
         <td><a href="http://wg21.link/p1002r1">P1002R1</a></td>
+        <td class="full" align="center">Clang 8</td>
       </tr>
       <tr>
         <td><a href="http://wg21.link/p1327r1">P1327R1</a></td>
+        <td rowspan=2 class="none" align="center">No</td>
       </tr>
       <tr>
         <td><a href="http://wg21.link/p1330r0">P1330R0</a></td>
       </tr>
     <tr>
       <td>Prohibit aggregates with user-declared constructors</td>
       <td><a href="http://wg21.link/p1008r1">P1008R1</a></td>
       <td class="svn" align="center">SVN</td>