| // RUN: %clang_cc1 -Wno-uninitialized -std=c++11 -verify %s |
| |
| template<int> struct c { c(int) = delete; typedef void val; operator int() const; }; |
| |
| int f; |
| int val; |
| int foobar; |
| struct S { |
| int k1 = a < b < c, d > ::val, e1; |
| int k2 = a < b, c < d > ::val, e2; |
| int k3 = b < a < c, d > ::val, e3; |
| int k4 = b < c, x, y = d > ::val, e4; |
| int k5 = T1 < b, &S::operator=(int); // expected-error {{extra qualification}} |
| int k6 = T2 < b, &S::operator= >::val; |
| int k7 = T1 < b, &S::operator>(int); // expected-error {{extra qualification}} |
| int k8 = T2 < b, &S::operator> >::val; |
| int k9 = T3 < a < b, c >> (d), e5 = 1 > (e4); |
| int k10 = 0 < T3 < a < b, c >> (d |
| ) // expected-error {{expected ';' at end of declaration}} |
| , a > (e4); |
| int k11 = 0 < 1, c<3>::*ptr; |
| int k12 = e < 0, int a<b<c>::* >(), e11; |
| |
| void f1( |
| int k1 = a < b < c, d > ::val, |
| int k2 = b < a < c, d > ::val, |
| int k3 = b < c, int x = 0 > ::val, |
| int k4 = a < b, T3 < int > >(), // expected-error {{must be an expression}} |
| int k5 = a < b, c < d > ::val, |
| int k6 = a < b, c < d > (n) // expected-error {{undeclared identifier 'n'}} |
| ); |
| |
| static void f1b( |
| int k6 = a < b, c < d > (f) |
| ); |
| using f1b_T = decltype(f1b(0)); // only one parameter, because second param |
| // would be missing its default argument |
| |
| void f2a( |
| // T3<int> here is a parameter type, so must be declared before it is used. |
| int k1 = c < b, T3 < int > x = 0 // expected-error {{no template named 'T3'}} |
| ); |
| |
| template<typename, int=0> struct T3 { T3(int); operator int(); }; |
| |
| void f2b( |
| int k1 = c < b, T3 < int > x = 0 // ok |
| ); |
| |
| // This is a one-parameter function. Ensure we don't typo-correct it to |
| // int = a < b, c < foobar > () |
| // ... which would be a function with two parameters. |
| int f3(int = a < b, c < goobar > ()); |
| static constexpr int (S::*f3_test)(int) = &S::f3; |
| |
| void f4( |
| int k1 = a<1,2>::val, |
| int missing_default // expected-error {{missing default argument on parameter}} |
| ); |
| |
| void f5( |
| int k1 = b < c, |
| int missing_default // expected-error {{missing default argument on parameter}} |
| ); |
| |
| // FIXME: We should ideally disambiguate this as two parameters. |
| void f6( |
| int k = b < c, // expected-error {{unexpected end of default argument}} |
| unsigned int (missing_default) |
| ); |
| |
| template<int, int = 0> struct a { // expected-note {{here}} |
| a(); |
| a(int); |
| static const int val = 0; |
| operator int(); |
| }; |
| static const int b = 0, c = 1, d = 2, goobar = 3; |
| template<int, typename> struct e { operator int(); }; |
| static const int f = 0; |
| |
| int mp1 = 0 < 1, |
| a<b<c,b<c>::*mp2, |
| mp3 = 0 > a<b<c>::val, |
| a<b<c,b<c>::*mp4 = 0, |
| a<b<c,b<c>::*mp5 {0}, |
| a<b<c,b<c>::*mp6; |
| |
| int np1 = e<0, int a<b<c,b<c>::*>(); |
| |
| static const int T1 = 4; |
| template<int, int &(S::*)(int)> struct T2 { static const int val = 0; }; |
| }; |
| |
| namespace NoAnnotationTokens { |
| template<bool> struct Bool { Bool(int); }; |
| static const bool in_class = false; |
| |
| struct Test { |
| // Check we don't keep around a Bool<false> annotation token here. |
| int f(Bool<true> = X<Y, Bool<in_class> >(0)); |
| |
| // But it's OK if we do here. |
| int g(Bool<true> = Z<Y, Bool<in_class> = Bool<false>(0)); |
| |
| static const bool in_class = true; |
| template<int, typename U> using X = U; |
| static const int Y = 0, Z = 0; |
| }; |
| } |
| |
| namespace ImplicitInstantiation { |
| template<typename T> struct HasError { typename T::error error; }; // expected-error {{has no members}} |
| |
| struct S { |
| // This triggers the instantiation of the outer HasError<int> during |
| // disambiguation, even though it uses the inner HasError<int>. |
| void f(int a = X<Y, HasError<int>::Z >()); // expected-note {{in instantiation of}} |
| |
| template<typename, typename> struct X { operator int(); }; |
| typedef int Y; |
| template<typename> struct HasError { typedef int Z; }; |
| }; |
| |
| HasError<int> hei; |
| } |
| |
| namespace CWG325 { |
| template <int A, typename B> struct T { static int i; operator int(); }; |
| class C { |
| int Foo (int i = T<1, int>::i); |
| }; |
| |
| class D { |
| int Foo (int i = T<1, int>::i); |
| template <int A, typename B> struct T {static int i;}; |
| }; |
| |
| const int a = 0; |
| typedef int b; |
| T<a,b> c; |
| struct E { |
| int n = T<a,b>(c); |
| }; |
| } |
| |
| namespace Operators { |
| struct Y {}; |
| constexpr int operator,(const Y&, const Y&) { return 8; } |
| constexpr int operator>(const Y&, const Y&) { return 8; } |
| constexpr int operator<(const Y&, const Y&) { return 8; } |
| constexpr int operator>>(const Y&, const Y&) { return 8; } |
| |
| struct X { |
| typedef int (*Fn)(const Y&, const Y&); |
| |
| Fn a = operator,, b = operator<, c = operator>; |
| void f(Fn a = operator,, Fn b = operator<, Fn c = operator>); |
| |
| int k1 = T1<0, operator<, operator>, operator<>::val, l1; |
| int k2 = T1<0, operator>, operator,, operator,>::val, l2; |
| int k3 = T2<0, operator,(Y{}, Y{}), operator<(Y{}, Y{})>::val, l3; |
| int k4 = T2<0, operator>(Y{}, Y{}), operator,(Y{}, Y{})>::val, l4; |
| int k5 = T3<0, operator>>>::val, l5; |
| int k6 = T4<0, T3<0, operator>>>>::val, l6; |
| |
| template<int, Fn, Fn, Fn> struct T1 { enum { val }; }; |
| template<int, int, int> struct T2 { enum { val }; }; |
| template<int, Fn> struct T3 { enum { val }; }; |
| template<int, typename T> struct T4 : T {}; |
| }; |
| } |
| |
| namespace ElaboratedTypeSpecifiers { |
| struct S { |
| int f(int x = T<a, struct S>()); |
| int h(int x = T<a, union __attribute__(()) U>()); |
| int i(int x = T<a, enum E>()); |
| int j(int x = T<a, struct S::template T<0, enum E>>()); |
| template <int, typename> struct T { operator int(); }; |
| static const int a = 0; |
| enum E {}; |
| }; |
| } |
| |
| namespace PR20459 { |
| template <typename EncTraits> struct A { |
| void foo(int = EncTraits::template TypeEnc<int, int>::val); // ok |
| }; |
| } |