[clang] P2266: apply move elision rules on throw expr nested in function prototypes

[mizvekov]

Summary

Our rules to determine if the throw expression are within the variable
scope were giving a false negative result in case the throw expression
would appear within a decltype in a nested function declaration.

Per P2266R3, the relevant rule is: [expr.prim.id.unqual]/2

if the id-expression (possibly parenthesized) is the operand of a throw-expression, and names an implicitly movable entity that belongs to a scope that does not contain the compound-statement of the innermost lambda-expression, try-block , or function-try-block (if any) whose compound-statement or ctor-initializer encloses the throw-expression.

This fixes PR54341.

Signed-off-by: Matheus Izvekov <[e-mail]>

[rsmith]

clang/lib/Sema/SemaExprCXX.cpp

849

Many of the remaining scope checks here also seem incorrect per the wording.

[mizvekov]

clang/lib/Sema/SemaExprCXX.cpp

849

Thanks, I left a FIXME for next time.

clang/lib/Sema/SemaExprCXX.cpp

if (DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(Ex->IgnoreParens()))
       if (VarDecl *Var = dyn_cast<VarDecl>(DRE->getDecl())) {
         if (Var->hasLocalStorage() && !Var->getType().isVolatileQualified()) {
           for( ; S; S = S->getParent()) {
             if (S->isDeclScope(Var)) {
               IsThrownVarInScope = true;
               break;
             }
 
+            // FIXME: Many of the scope checks here seem incorrect.
             if (S->getFlags() &
                 (Scope::FnScope | Scope::ClassScope | Scope::BlockScope |
-                 Scope::FunctionPrototypeScope | Scope::ObjCMethodScope |
-                 Scope::TryScope))
+                 Scope::ObjCMethodScope | Scope::TryScope))
               break;
           }
         }
       }
   }
 
   return BuildCXXThrow(OpLoc, Ex, IsThrownVarInScope);
 }

clang/test/CXX/class/class.init/class.copy.elision/p3.cpp

 // catch-clause parameter.
 namespace test_throw_parameter {
 void func();
 
 struct A1 {
   A1(const A1 &);
   A1(A1 &&) = delete;
   // expected-note@-1 2{{'A1' has been explicitly marked deleted here}}
-  // cxx11_2b-note@-2  {{'A1' has been explicitly marked deleted here}}
+  // cxx11_2b-note@-2 3{{'A1' has been explicitly marked deleted here}}
 };
 void test1() {
   try {
     func();
   } catch (A1 a) {
     throw a; // expected-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
   }
 }

 } catch (...) {
   throw a; // expected-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
 }
 
 #if __cplusplus >= 201103L
 namespace PR54341 {
 void test4(A1 a) {
   void f(decltype((throw a, 0)));
-  // expected-warning@-1 {{has no effect}}
+  // expected-error@-1 {{call to deleted constructor of 'test_throw_parameter::A1'}}
 
   void g(int = decltype(throw a, 0){});
-  // expected-warning@-1 {{has no effect}}
+  // expected-error@-1 {{call to deleted constructor of 'test_throw_parameter::A1'}}
 }
 
 void test5(A1 a, int = decltype(throw a, 0){}) {}
 // expected-error@-1 {{call to deleted constructor of 'test_throw_parameter::A1'}}
 } // namespace PR54341
 #endif
 
 } // namespace test_throw_parameter