diff options
author | Richard Smith <richard-llvm@metafoo.co.uk> | 2012-02-23 01:36:12 +0000 |
---|---|---|
committer | Richard Smith <richard-llvm@metafoo.co.uk> | 2012-02-23 01:36:12 +0000 |
commit | d81e961f905e3ea57f6808e5a5686a8324270984 (patch) | |
tree | 3946ebade6837b57bde087c7f14da50d5c826627 /test/Parser | |
parent | 47611c88fb0446673c6e590ab461934054be290a (diff) |
Update parser's disambiguation to cope with braced function-style casts in
C++11, and with braced-init-list initializers in conditions. This exposed an
ambiguity with enum underlying types versus bitfields, which we resolve by
treating 'enum E : T {' as always defining an enumeration (even if it would
only successfully parse as a bitfield). This appears to be g++ compatible.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@151227 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'test/Parser')
-rw-r--r-- | test/Parser/cxx0x-ambig.cpp | 92 | ||||
-rw-r--r-- | test/Parser/cxx0x-condition.cpp | 8 |
2 files changed, 96 insertions, 4 deletions
diff --git a/test/Parser/cxx0x-ambig.cpp b/test/Parser/cxx0x-ambig.cpp new file mode 100644 index 0000000000..c955dc1690 --- /dev/null +++ b/test/Parser/cxx0x-ambig.cpp @@ -0,0 +1,92 @@ +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s + +// New exciting ambiguities in C++11 + +// final 'context sensitive' mess. +namespace final { + struct S { int n; }; + namespace N { + int n; + // This defines a class, not a variable, even though it would successfully + // parse as a variable but not as a class. DR1318's wording suggests that + // this disambiguation is only performed on an ambiguity, but that was not + // the intent. + struct S final { + int(n) // expected-error {{expected ';'}} + }; + } +} + +// enum versus bitfield mess. +namespace bitfield { + enum E {}; + + struct T { + constexpr T() {} + constexpr T(int) {} + constexpr T(T, T, T, T) {} + constexpr T operator=(T) { return *this; } + constexpr operator int() { return 4; } + }; + constexpr T a, b, c, d; + + struct S1 { + enum E : T ( a = 1, b = 2, c = 3, 4 ); // ok, declares a bitfield + }; + // This could be a bit-field. + struct S2 { + enum E : T { a = 1, b = 2, c = 3, 4 }; // expected-error {{non-integral type}} expected-error {{expected '}'}} expected-note {{to match}} + }; + struct S3 { + enum E : int { a = 1, b = 2, c = 3, d }; // ok, defines an enum + }; + // Ambiguous. + struct S4 { + enum E : int { a = 1 }; // ok, defines an enum + }; + // This could be a bit-field, but would be ill-formed due to the anonymous + // member being initialized. + struct S5 { + enum E : int { a = 1 } { b = 2 }; // expected-error {{expected member name}} + }; + // This could be a bit-field. + struct S6 { + enum E : int { 1 }; // expected-error {{expected '}'}} expected-note {{to match}} + }; + + struct U { + constexpr operator T() { return T(); } // expected-note 2{{candidate}} + }; + // This could be a bit-field. + struct S7 { + enum E : int { a = U() }; // expected-error {{no viable conversion}} + }; + // This could be a bit-field, and does not conform to the grammar of an + // enum definition, because 'id(U())' is not a constant-expression. + constexpr const U &id(const U &u) { return u; } + struct S8 { + enum E : int { a = id(U()) }; // expected-error {{no viable conversion}} + }; +} + +namespace trailing_return { + typedef int n; + int a; + + struct S { + S(int); + S *operator()() const; + int n; + }; + + namespace N { + void f() { + // This parses as a function declaration, but DR1223 makes the presence of + // 'auto' be used for disambiguation. + S(a)()->n; // ok, expression; expected-warning{{expression result unused}} + auto(a)()->n; // ok, function declaration + using T = decltype(a); + using T = auto() -> n; + } + } +} diff --git a/test/Parser/cxx0x-condition.cpp b/test/Parser/cxx0x-condition.cpp index ce7d1a8aef..e45cd866ff 100644 --- a/test/Parser/cxx0x-condition.cpp +++ b/test/Parser/cxx0x-condition.cpp @@ -27,11 +27,11 @@ void f() { if (S b(n) = 0) {} // expected-error {{a function type is not allowed here}} if (S b(n) == 0) {} // expected-error {{a function type is not allowed here}} expected-error {{did you mean '='?}} - // FIXME: this is legal, and incorrectly rejected, because tentative parsing - // does not yet know about braced function-style casts. - if (S{a}) {} // unexpected-error{{unqualified-id}} - + if (S{a}) {} // ok if (S a{a}) {} // ok if (S a = {a}) {} // ok if (S a == {a}) {} // expected-error {{did you mean '='?}} + + if (S(b){a}) {} // ok + if (S(b) = {a}) {} // ok } |