PR16480: Reimplement token-caching for constructor initializer lists. This
previously didn't work if a mem-initializer-id had a template argument which
contained parentheses or braces.
We now implement a simple rule: just look for a ') {' or '} {' that is not
nested. The '{' is assumed to start the function-body. There are still two
cases which we misparse, where the ') {' comes from a compound literal or
from a lambda. The former case is not valid C++, and the latter will probably
not be valid C++ once DR1607 is resolved, so these seem to be of low value,
and we do not regress on them with this change. EDG and g++ also misparse
both of these cases.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@185598 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/test/Parser/cxx-member-initializers.cpp b/test/Parser/cxx-member-initializers.cpp
index 5c39068..ff8c880 100644
--- a/test/Parser/cxx-member-initializers.cpp
+++ b/test/Parser/cxx-member-initializers.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fsyntax-only -verify %s
+// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
struct x {
x() : a(4) ; // expected-error {{expected '{'}}
@@ -11,5 +11,71 @@
struct z {
int a;
- z() : a {} // expected-error {{expected '('}}
-};
+ z() : a {}
+}; // expected-error {{expected '{'}}
+
+namespace PR16480 {
+ template<int n> struct X {
+ X();
+ X(int);
+ };
+
+ struct A : X<0> {
+ A() : X<a<b>{0}.n>() {}
+
+ template<int> struct a {
+ int n;
+ };
+
+ static const int b = 1;
+ };
+
+ struct B : X<0> {
+ B() : X<a<b>{0} {}
+
+ static const int a = 0, b = 0;
+ };
+
+ template<int> struct a {
+ constexpr a(int) {}
+ constexpr operator int() const { return 0; }
+ };
+
+ struct C : X<0> {
+ C() : X<a<b>(0)>() {}
+
+ static const int b = 0;
+ };
+
+ struct D : X<0> {
+ D() : X<a<b>(0) {}
+
+ static const int a = 0, b = 0;
+ };
+
+ template<typename T> struct E : X<0> {
+ E(X<0>) : X<(0)>{} {}
+ E(X<1>) : X<int{}>{} {}
+ E(X<2>) : X<(0)>() {}
+ E(X<3>) : X<int{}>() {}
+ };
+
+ // FIXME: This should be valid in the union of C99 and C++11.
+ struct F : X<0> {
+ F() : X<A<T>().n + (T){}.n>{} {} // expected-error +{{}}
+
+ struct T { int n; };
+ template<typename> struct A { int n; };
+ }; // expected-error +{{}}
+
+ // FIXME: This is valid now, but may be made ill-formed by DR1607.
+ struct G : X<0> {
+ G() : X<0 && [](){return 0;}()>{} // expected-error +{{}}
+ }; // expected-error +{{}}
+
+ struct Errs : X<0> {
+ Errs(X<0>) : decltype X<0>() {} // expected-error {{expected '(' after 'decltype'}}
+ Errs(X<1>) : what is this () {} // expected-error {{expected '(' or '{'}}
+ Errs(X<2>) : decltype(X<0> // expected-note {{to match this '('}}
+ }; // expected-error {{expected ')'}}
+}