clang/test/SemaCXX/trailing-return-0x.cpp

   1 // RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
   2
   3 template <class T>
   4 struct only
   5 {
   6     only(T) {}
   7
   8     template <class U>
   9     only(U)
  10     {
  11         static_assert(sizeof(U) == 0, "expected type failure");
  12     }
  13 };
  14
  15 auto f() -> int
  16 {
  17     return 0;
  18 }
  19
  20 auto g(); // expected-error{{return without trailing return type; deduced return types are a C++14 extension}}
  21 decltype(auto) g2(); // expected-warning{{extension}} expected-error-re{{{{^}}deduced return types are a C++14 extension}}
  22 auto badness = g2();
  23
  24 int h() -> int; // expected-error{{trailing return type must specify return type 'auto', not 'int'}}
  25
  26 int i();
  27 auto i() -> int;
  28 int i() {}
  29
  30 using T = auto (int) -> auto (*)(char) -> void; // expected-note {{previous}}
  31 using T = void; // expected-error {{type alias redefinition with different types ('void' vs 'auto (int) -> auto (*)(char) -> void')}}
  32
  33 using U = auto (int) -> auto (*)(char) -> void;
  34 using U = void (*(int))(char); // ok
  35
  36 int x;
  37
  38 template <class T>
  39 auto i(T x) -> decltype(x)
  40 {
  41     return x;
  42 }
  43
  44 only<double> p1 = i(1.0);
  45
  46 template <class T>
  47 struct X
  48 {
  49     auto f(T x) -> T { return x; }
  50
  51     template <class U>
  52     auto g(T x, U y) -> decltype(x + y)
  53     {
  54         return x + y;
  55     }
  56
  57   template<typename U>
  58   struct nested {
  59     template <class V>
  60     auto h(T x, U y, V z) -> decltype(x + y + z)
  61     {
  62         return x + y + z;
  63     }
  64   };
  65
  66   template<typename U>
  67   nested<U> get_nested();
  68 };
  69
  70 X<int> xx;
  71 only<int> p2 = xx.f(0L);
  72 only<double> p3 = xx.g(0L, 1.0);
  73 only<double> p4 = xx.get_nested<double>().h(0L, 1.0, 3.14f);
  74
  75 namespace PR12053 {
  76   template <typename T>
  77   auto f1(T t) -> decltype(f1(t)) {} // expected-note{{candidate template ignored}}
  78
  79   void test_f1() {
  80     f1(0); // expected-error{{no matching function for call to 'f1'}}
  81   }
  82
  83   template <typename T>
  84   auto f2(T t) -> decltype(f2(&t)) {} // expected-note{{candidate template ignored}}
  85
  86   void test_f2() {
  87     f2(0); // expected-error{{no matching function for call to 'f2'}}
  88   }
  89 }
  90
  91 namespace DR1608 {
  92   struct S {
  93     void operator+();
  94     int operator[](int);
  95     auto f() -> decltype(+*this); // expected-note {{here}}
  96     auto f() -> decltype((*this)[0]); // expected-error {{cannot be overloaded}}
  97   };
  98 }
  99
 100 namespace PR16273 {
 101   struct A {
 102     template <int N> void f();
 103     auto g()->decltype(this->f<0>());
 104   };
 105 }
 106
 107 namespace PR46637 {
 108   using A = auto () -> auto; // expected-error {{'auto' not allowed in function return type}}
 109   using B = auto (*)() -> auto; // expected-error {{'auto' not allowed in function return type}}
 110   template<auto (*)() -> auto> struct X {}; // expected-error {{'auto' not allowed in function return type}}
 111   template<typename T> struct Y { T x; };
 112   Y<auto() -> auto> y; // expected-error {{'auto' not allowed in function return type}}
 113 }