summaryrefslogtreecommitdiff
path: root/clang/test/SemaTemplate/instantiate-self.cpp
blob: cfe902509f7fc6619fae932efae790b973df992f (about) (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
// RUN: %clang_cc1 -std=c++11 -verify %s

// Check that we deal with cases where the instantiation of a class template
// recursively requires the instantiation of the same template.
namespace test1 {
  template<typename T> struct A {
    struct B { // expected-note {{not complete until the closing '}'}}
      B b; // expected-error {{has incomplete type 'test1::A<int>::B'}}
    };
    B b; // expected-note {{in instantiation of}}
  };
  A<int> a; // expected-note {{in instantiation of}}
}

namespace test2 {
  template<typename T> struct A {
    struct B {
      struct C {};
      char c[1 + C()]; // expected-error {{invalid operands to binary expression}}
      friend constexpr int operator+(int, C) { return 4; }
    };
    B b; // expected-note {{in instantiation of}}
  };
  A<int> a; // expected-note {{in instantiation of}}
}

namespace test3 {
  // PR12317
  template<typename T> struct A {
    struct B {
      enum { Val = 1 };
      char c[1 + Val]; // ok
    };
    B b;
  };
  A<int> a;
}

namespace test4 {
  template<typename T> struct M { typedef int type; };
  template<typename T> struct A {
    struct B { // expected-note {{not complete until the closing '}'}}
      int k[typename A<typename M<T>::type>::B().k[0] + 1]; // expected-error {{incomplete type}}
    };
    B b; // expected-note {{in instantiation of}}
  };
  A<int> a; // expected-note {{in instantiation of}}
}

// FIXME: PR12298: Recursive constexpr function template instantiation leads to
// stack overflow.
#if 0
namespace test5 {
  template<typename T> struct A {
    constexpr T f(T k) { return g(k); }
    constexpr T g(T k) {
      return k ? f(k-1)+1 : 0;
    }
  };
  // This should be accepted.
  constexpr int x = A<int>().f(5);
}

namespace test6 {
  template<typename T> constexpr T f(T);
  template<typename T> constexpr T g(T t) {
    typedef int arr[f(T())];
    return t;
  }
  template<typename T> constexpr T f(T t) {
    typedef int arr[g(T())];
    return t;
  }
  // This should be ill-formed.
  int n = f(0);
}

namespace test7 {
  template<typename T> constexpr T g(T t) {
    return t;
  }
  template<typename T> constexpr T f(T t) {
    typedef int arr[g(T())];
    return t;
  }
  // This should be accepted.
  int n = f(0);
}
#endif