summaryrefslogtreecommitdiff
path: root/clang/test/CXX/temp/temp.spec/temp.explicit/p1.cpp
blob: b42633924e828a7a431d099628e70ed4d4449d2c (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 -fsyntax-only -verify %s

struct C { };

template<typename T>
struct X0 {
  T value; // expected-error{{incomplete}}
};

// Explicitly instantiate a class template specialization
template struct X0<int>;
template struct X0<void>; // expected-note{{instantiation}}

// Explicitly instantiate a function template specialization
template<typename T>
void f0(T t) {
  ++t; // expected-error{{cannot increment}}
}

template void f0(int);
template void f0<long>(long);
template void f0<>(unsigned);
template void f0(int C::*); // expected-note{{instantiation}}

// Explicitly instantiate a member template specialization
template<typename T>
struct X1 {
  template<typename U>
  struct Inner {
    T member1;
    U member2; // expected-error{{incomplete}}
  };
  
  template<typename U>
  void f(T& t, U u) {
    t = u; // expected-error{{incompatible}}
  }
};

template struct X1<int>::Inner<float>;
template struct X1<int>::Inner<double>;
template struct X1<int>::Inner<void>; // expected-note{{instantiation}}

template void X1<int>::f(int&, float);
template void X1<int>::f<long>(int&, long);
template void X1<int>::f<>(int&, double);
template void X1<int>::f<>(int&, int*); // expected-note{{instantiation}}

// Explicitly instantiate members of a class template
struct Incomplete; // expected-note{{forward declaration}}
struct NonDefaultConstructible { // expected-note{{candidate constructor (the implicit copy constructor) not viable}}
  NonDefaultConstructible(int); // expected-note{{candidate constructor}}
};

template<typename T, typename U>
struct X2 {
  void f(T &t, U u) { 
    t = u; // expected-error{{incompatible}}
  }
  
  struct Inner {
    T member1;
    U member2; // expected-error{{incomplete}}
  };
  
  static T static_member1;
  static U static_member2;
};

template<typename T, typename U>
T X2<T, U>::static_member1 = 17; // expected-error{{cannot initialize}}

template<typename T, typename U>
U X2<T, U>::static_member2; // expected-error{{no matching}}

template void X2<int, float>::f(int &, float);
template void X2<int, float>::f(int &, double); // expected-error{{does not refer}}
template void X2<int, int*>::f(int&, int*); // expected-note{{instantiation}}

template struct X2<int, float>::Inner;
template struct X2<int, Incomplete>::Inner; // expected-note{{instantiation}}

template int X2<int, float>::static_member1;
template int* X2<int*, float>::static_member1; // expected-note{{instantiation}}
template 
  NonDefaultConstructible X2<NonDefaultConstructible, int>::static_member1;

template 
  NonDefaultConstructible X2<int, NonDefaultConstructible>::static_member2; // expected-note{{instantiation}}