107 lines
2.3 KiB
C++
107 lines
2.3 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
|
|
|
|
template <class T>
|
|
struct only
|
|
{
|
|
only(T) {}
|
|
|
|
template <class U>
|
|
only(U)
|
|
{
|
|
static_assert(sizeof(U) == 0, "expected type failure");
|
|
}
|
|
};
|
|
|
|
auto f() -> int
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
auto g(); // expected-error{{return without trailing return type; deduced return types are a C++14 extension}}
|
|
decltype(auto) g2(); // expected-warning{{extension}} expected-error-re{{{{^}}deduced return types are a C++14 extension}}
|
|
auto badness = g2();
|
|
|
|
int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}}
|
|
|
|
int i();
|
|
auto i() -> int;
|
|
int i() {}
|
|
|
|
using T = auto (int) -> auto (*)(char) -> void; // expected-note {{previous}}
|
|
using T = void; // expected-error {{type alias redefinition with different types ('void' vs 'auto (int) -> auto (*)(char) -> void')}}
|
|
|
|
using U = auto (int) -> auto (*)(char) -> void;
|
|
using U = void (*(int))(char); // ok
|
|
|
|
int x;
|
|
|
|
template <class T>
|
|
auto i(T x) -> decltype(x)
|
|
{
|
|
return x;
|
|
}
|
|
|
|
only<double> p1 = i(1.0);
|
|
|
|
template <class T>
|
|
struct X
|
|
{
|
|
auto f(T x) -> T { return x; }
|
|
|
|
template <class U>
|
|
auto g(T x, U y) -> decltype(x + y)
|
|
{
|
|
return x + y;
|
|
}
|
|
|
|
template<typename U>
|
|
struct nested {
|
|
template <class V>
|
|
auto h(T x, U y, V z) -> decltype(x + y + z)
|
|
{
|
|
return x + y + z;
|
|
}
|
|
};
|
|
|
|
template<typename U>
|
|
nested<U> get_nested();
|
|
};
|
|
|
|
X<int> xx;
|
|
only<int> p2 = xx.f(0L);
|
|
only<double> p3 = xx.g(0L, 1.0);
|
|
only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f);
|
|
|
|
namespace PR12053 {
|
|
template <typename T>
|
|
auto f1(T t) -> decltype(f1(t)) {} // expected-note{{candidate template ignored}}
|
|
|
|
void test_f1() {
|
|
f1(0); // expected-error{{no matching function for call to 'f1'}}
|
|
}
|
|
|
|
template <typename T>
|
|
auto f2(T t) -> decltype(f2(&t)) {} // expected-note{{candidate template ignored}}
|
|
|
|
void test_f2() {
|
|
f2(0); // expected-error{{no matching function for call to 'f2'}}
|
|
}
|
|
}
|
|
|
|
namespace DR1608 {
|
|
struct S {
|
|
void operator+();
|
|
int operator[](int);
|
|
auto f() -> decltype(+*this); // expected-note {{here}}
|
|
auto f() -> decltype((*this)[0]); // expected-error {{cannot be overloaded}}
|
|
};
|
|
}
|
|
|
|
namespace PR16273 {
|
|
struct A {
|
|
template <int N> void f();
|
|
auto g()->decltype(this->f<0>());
|
|
};
|
|
}
|
|
|