Unnamed: 0
int64 0
0
| repo_id
stringlengths 5
186
| file_path
stringlengths 15
223
| content
stringlengths 1
32.8M
⌀ |
|---|---|---|---|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.decls/temp.class
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.decls/temp.class/temp.static/p1-inst.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// Test instantiation of static data members declared out-of-line.
template<typename T>
struct X {
static T value;
};
template<typename T>
T X<T>::value = 17; // expected-error{{no viable conversion}}
struct InitOkay {
InitOkay(int) { }
};
struct CannotInit { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}}
int &returnInt() { return X<int>::value; }
float &returnFloat() { return X<float>::value; }
InitOkay &returnInitOkay() { return X<InitOkay>::value; }
unsigned long sizeOkay() { return sizeof(X<CannotInit>::value); }
CannotInit &returnError() {
return X<CannotInit>::value; // expected-note{{instantiation}}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.decls/temp.class
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.decls/temp.class/temp.static/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
struct X0 {
static T value;
};
template<typename T>
T X0<T>::value = 0; // expected-error{{no viable conversion}}
struct X1 {
X1(int);
};
struct X2 { }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}}
int& get_int() { return X0<int>::value; }
X1& get_X1() { return X0<X1>::value; }
double*& get_double_ptr() { return X0<int*>::value; } // expected-error{{non-const lvalue reference to type 'double *' cannot bind to a value of unrelated type 'int *'}}
X2& get_X2() {
return X0<X2>::value; // expected-note{{instantiation}}
}
template<typename T> T x; // expected-warning{{variable templates are a C++14 extension}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.type/p1-0x.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
namespace Old {
template<template<class> class TT> struct X { };
template<class> struct Y { };
template<class T> using Z = Y<T>;
X<Y> y;
X<Z> z;
using SameType = decltype(y); // expected-note {{here}}
using SameType = decltype(z); // expected-error {{different types}}
}
namespace New {
template<class T> struct X { };
template<class> struct Y { };
template<class T> using Z = Y<T>;
X<Y<int>> y;
X<Z<int>> z;
using SameType = decltype(y);
using SameType = decltype(z); // ok
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/cxx1y-variable-template-no-body.cpp
|
// RUN: %clang_cc1 --std=c++1y -fsyntax-only -verify %s
// RUN: cp %s %t
// RUN: not %clang_cc1 --std=c++1y -x c++ -fixit %t -DFIXING
// RUN: %clang_cc1 --std=c++1y -x c++ %t -DFIXING
template<typename T>
T pi = T(3.1415926535897932385); // expected-note {{template is declared here}}
template int pi<int>;
#ifndef FIXING
template float pi<>; // expected-error {{too few template arguments for template 'pi'}}
template double pi_var0; // expected-error {{explicit instantiation of 'pi_var0' does not refer to a function template, variable template, member function, member class, or static data member}}
#endif
// Should recover as if definition
template double pi_var = 5; // expected-error {{variable cannot be defined in an explicit instantiation; if this declaration is meant to be a variable definition, remove the 'template' keyword}}
#ifndef FIXING
template<typename T>
T pi0 = T(3.1415926535897932385); // expected-note {{previous definition is here}}
template int pi0 = 10; // expected-error {{variable cannot be defined in an explicit instantiation; if this declaration is meant to be a variable definition, remove the 'template' keyword}} \
expected-error{{redefinition of 'pi0' as different kind of symbol}}
#endif
template<typename T>
T pi1 = T(3.1415926535897932385); // expected-note 0-2 {{here}}
// Should recover as if specialization
template float pi1<float> = 1.0; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}
#ifndef FIXING
namespace expected_global {
template<> double pi1<double> = 1.5; // expected-error {{variable template specialization of 'pi1' must originally be declared in the global scope}}
template int pi1<int> = 10; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \
expected-error {{variable template specialization of 'pi1' must originally be declared in the global scope}}
}
#endif
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/no-body.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// RUN: cp %s %t
// RUN: not %clang_cc1 -x c++ -fixit %t -DFIXING
// RUN: %clang_cc1 -x c++ %t -DFIXING
template<typename T> void f(T) { }
template<typename T> void g(T) { }
template<typename T> struct x { };
template<typename T> struct y { }; // expected-note {{declared here}}
namespace good {
template void f<int>(int);
template void g(int);
template struct x<int>;
}
namespace unsupported {
#ifndef FIXING
template struct y; // expected-error {{elaborated type refers to a template}}
#endif
}
template<typename T> void f0(T) { }
template<typename T> void g0(T) { }
template<typename T> struct x0 { }; // expected-note {{explicitly specialized declaration is here}}
template<typename T> struct y0 { };
// Should recover as if definition
namespace noargs_body {
#ifndef FIXING
template void g0(int) { } // expected-error {{function cannot be defined in an explicit instantiation; if this declaration is meant to be a function definition, remove the 'template' keyword}}
#endif
template struct y0 { }; // expected-error {{class cannot be defined in an explicit instantiation; if this declaration is meant to be a class definition, remove the 'template' keyword}}
}
// Explicit specializations expected in global scope
namespace exp_spec {
#ifndef FIXING
template<> void f0<int>(int) { } // expected-error {{no function template matches function template specialization 'f0'}}
template<> struct x0<int> { }; // expected-error {{class template specialization of 'x0' must occur at global scope}}
#endif
}
template<typename T> void f1(T) { }
template<typename T> struct x1 { }; // expected-note {{explicitly specialized declaration is here}}
// Should recover as if specializations,
// thus also complain about not being in global scope.
namespace args_bad {
#ifndef FIXING
template void f1<int>(int) { } // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \
expected-error {{no function template matches function template specialization 'f1'}}
template struct x1<int> { }; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}} \
expected-error {{class template specialization of 'x1' must occur at global scope}}
#endif
}
template<typename T> void f2(T) { }
template<typename T> struct x2 { };
// Should recover as if specializations
template void f2<int>(int) { } // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}
template struct x2<int> { }; // expected-error {{explicit template instantiation cannot have a definition; if this definition is meant to be an explicit specialization, add '<>' after the 'template' keyword}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/p5.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T> inline void f(T) { }
template void f(int); // expected-note{{previous explicit instantiation}}
template void f(int); // expected-error{{duplicate explicit instantiation}}
template<typename T>
struct X0 {
union Inner { };
void f(T) { }
static T value;
};
template<typename T>
T X0<T>::value = 3.14; // expected-warning{{implicit conversion from 'double' to 'int' changes value from 3.14 to 3}}
template struct X0<int>; // expected-note{{previous explicit instantiation}} \
expected-note{{requested here}}
template struct X0<int>; // expected-error{{duplicate explicit instantiation}}
template void X0<float>::f(float); // expected-note{{previous explicit instantiation}}
template void X0<float>::f(float); // expected-error{{duplicate explicit instantiation}}
template union X0<float>::Inner; // expected-note{{previous explicit instantiation}}
template union X0<float>::Inner; // expected-error{{duplicate explicit instantiation}}
template float X0<float>::value; // expected-note{{previous explicit instantiation}}
template float X0<float>::value; // expected-error{{duplicate explicit instantiation}}
// Make sure that we don't get tricked by redeclarations of nested classes.
namespace NestedClassRedecls {
template<typename T>
struct X {
struct Nested;
friend struct Nested;
struct Nested {
Nested() {}
} nested;
};
X<int> xi;
template struct X<int>;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.inst/p1.cpp
|
// RUN: %clang_cc1 -std=c++11 -verify %s
// The implicit specialization of a class template specialuzation causes the
// implicit instantiation of the declarations, but not the definitions or
// default arguments, of:
// FIXME: Many omitted cases
// - scoped member enumerations
namespace ScopedEnum {
template<typename T> struct ScopedEnum1 {
enum class E {
e = T::error // expected-error {{'double' cannot be used prior to '::'}}
};
};
ScopedEnum1<int> se1; // ok
template<typename T> struct ScopedEnum2 {
enum class E : T { // expected-error {{non-integral type 'void *' is an invalid underlying type}}
e = 0
};
};
ScopedEnum2<void*> se2; // expected-note {{here}}
template<typename T> struct UnscopedEnum3 {
enum class E : T {
e = 4
};
int arr[(int)E::e];
};
UnscopedEnum3<int> ue3; // ok
ScopedEnum1<double>::E e1; // ok
ScopedEnum1<double>::E e2 = decltype(e2)::e; // expected-note {{in instantiation of enumeration 'ScopedEnum::ScopedEnum1<double>::E' requested here}}
// DR1484 specifies that enumerations cannot be separately instantiated,
// they will be instantiated with the rest of the template declaration.
template<typename T>
int f() {
enum class E {
e = T::error // expected-error {{has no members}}
};
return (int)E();
}
int test1 = f<int>(); // expected-note {{here}}
template<typename T>
int g() {
enum class E {
e = T::error // expected-error {{has no members}}
};
return E::e;
}
int test2 = g<int>(); // expected-note {{here}}
}
// And it cases the implicit instantiations of the definitions of:
// - unscoped member enumerations
namespace UnscopedEnum {
template<typename T> struct UnscopedEnum1 {
enum E {
e = T::error // expected-error {{'int' cannot be used prior to '::'}}
};
};
UnscopedEnum1<int> ue1; // expected-note {{here}}
template<typename T> struct UnscopedEnum2 {
enum E : T { // expected-error {{non-integral type 'void *' is an invalid underlying type}}
e = 0
};
};
UnscopedEnum2<void*> ue2; // expected-note {{here}}
template<typename T> struct UnscopedEnum3 {
enum E : T {
e = 4
};
int arr[E::e];
};
UnscopedEnum3<int> ue3; // ok
template<typename T>
int f() {
enum E {
e = T::error // expected-error {{has no members}}
};
return (int)E();
}
int test1 = f<int>(); // expected-note {{here}}
template<typename T>
int g() {
enum E {
e = T::error // expected-error {{has no members}}
};
return E::e;
}
int test2 = g<int>(); // expected-note {{here}}
}
// FIXME:
//- - member anonymous unions
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.inst/p11.cpp
|
// RUN: %clang_cc1 -verify -emit-llvm-only %s
// rdar://problem/7838962
namespace test0 {
template<typename T> unsigned f0() {
return T::MaxSize; // expected-error {{'int' cannot be used prior to '::'}}
};
template<typename T> struct A {
void Allocate(unsigned Alignment
= f0<T>()) // expected-note {{in instantiation}}
{}
};
void f1(A<int> x) { x.Allocate(); }
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p7.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
struct X0 {
struct MemberClass {
T member; // expected-error{{with function type}}
};
T* f0(T* ptr) {
return ptr + 1; // expected-error{{pointer to the function}}
}
static T* static_member;
};
template<typename T>
T* X0<T>::static_member = ((T*)0) + 1; // expected-error{{pointer to the function}}
template class X0<int>; // okay
template class X0<int(int)>; // expected-note 3{{requested here}}
// Specialize everything, so that the explicit instantiation does not trigger
// any diagnostics.
template<>
struct X0<int(long)>::MemberClass { };
typedef int int_long_func(long);
template<>
int_long_func *X0<int_long_func>::f0(int_long_func *) { return 0; }
template<>
int_long_func *X0<int(long)>::static_member;
template class X0<int(long)>;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p9.cpp
|
// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
template<typename T>
struct X0 {
void f(T &t) {
t = 1; // expected-error{{incompatible type}}
}
void g(T &t);
void h(T &t);
static T static_var;
};
template<typename T>
inline void X0<T>::g(T & t) {
t = 1; // expected-error{{incompatible type}}
}
template<typename T>
void X0<T>::h(T & t) {
t = 1;
}
template<typename T>
T X0<T>::static_var = 1;
extern template struct X0<int*>;
int *&test(X0<int*> xi, int *ip) {
xi.f(ip); // expected-note{{instantiation}}
xi.g(ip); // expected-note{{instantiation}}
xi.h(ip);
return X0<int*>::static_var;
}
template<typename T>
void f0(T& t) {
t = 1; // expected-error{{incompatible type}}
}
template<typename T>
inline void f1(T& t) {
t = 1; // expected-error 2{{incompatible type}}
}
extern template void f0<>(int *&);
extern template void f1<>(int *&);
void test_f0(int *ip, float *fp) {
f0(ip);
f0(fp); // expected-note{{instantiation}}
}
void test_f1(int *ip, float *fp) {
f1(ip); // expected-note{{instantiation}}
f1(fp); // expected-note{{instantiation}}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p8.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
template<typename T>
struct X0 {
struct MemberClass;
T* f0(T* ptr);
static T* static_member;
};
template class X0<int(int)>; // ok; nothing gets instantiated.
template<typename T>
struct X0<T>::MemberClass {
T member;
};
template<typename T>
T* X0<T>::f0(T* ptr) {
return ptr + 1;
}
template<typename T>
T* X0<T>::static_member = 0;
template class X0<int>; // ok
template<typename T>
struct X1 {
enum class E {
e = T::error // expected-error 2{{no members}}
};
};
template struct X1<int>; // expected-note {{here}}
extern template struct X1<char>; // ok
template struct X1<char>; // expected-note {{here}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p10.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
struct X0 {
void f(T&);
struct Inner;
static T static_var;
};
template<typename T>
void X0<T>::f(T& t) {
t = 1; // expected-error{{incompatible type}}
}
template<typename T>
struct X0<T>::Inner {
T member;
};
template<typename T>
T X0<T>::static_var = 1; // expected-error{{cannot initialize}}
extern template struct X0<void*>;
template struct X0<void*>; // expected-note 2{{instantiation}}
template struct X0<int>; // expected-note 4{{explicit instantiation definition is here}}
extern template void X0<int>::f(int&); // expected-error{{follows explicit instantiation definition}}
extern template struct X0<int>::Inner; // expected-error{{follows explicit instantiation definition}}
extern template int X0<int>::static_var; // expected-error{{follows explicit instantiation definition}}
extern template struct X0<int>; // expected-error{{follows explicit instantiation definition}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p4.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -pedantic %s
template<typename T> void f0(T); // expected-note{{here}}
template void f0(int); // expected-error{{explicit instantiation of undefined function template}}
template<typename T>
struct X0 {
struct Inner;
void f1(); // expected-note{{here}}
static T value; // expected-note{{here}}
};
template void X0<int>::f1(); // expected-error{{explicit instantiation of undefined member function}}
template int X0<int>::value; // expected-error{{explicit instantiation of undefined static data member}}
template<> void f0(long); // expected-note{{previous template specialization is here}}
template void f0(long); // expected-warning{{explicit instantiation of 'f0<long>' that occurs after an explicit specialization will be ignored}}
template<> void X0<long>::f1(); // expected-note{{previous template specialization is here}}
template void X0<long>::f1(); // expected-warning{{explicit instantiation of 'f1' that occurs after an explicit specialization will be ignored}}
template<> struct X0<long>::Inner; // expected-note{{previous template specialization is here}}
template struct X0<long>::Inner; // expected-warning{{explicit instantiation of 'Inner' that occurs after an explicit specialization will be ignored}}
template<> long X0<long>::value; // expected-note{{previous template specialization is here}}
template long X0<long>::value; // expected-warning{{explicit instantiation of 'value' that occurs after an explicit specialization will be ignored}}
template<> struct X0<double>; // expected-note{{previous template specialization is here}}
template struct X0<double>; // expected-warning{{explicit instantiation of 'X0<double>' that occurs after an explicit specialization will be ignored}}
// PR 6458
namespace test0 {
template <class T> class foo {
int compare(T x, T y);
};
template <> int foo<char>::compare(char x, char y);
template <class T> int foo<T>::compare(T x, T y) {
// invalid at T=char; if we get a diagnostic here, we're
// inappropriately instantiating this template.
void *ptr = x;
}
extern template class foo<char>; // expected-warning {{extern templates are a C++11 extension}}
template class foo<char>;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p3.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s
// A declaration of a function template shall be in scope at the point of the
// explicit instantiation of the function template.
template<typename T> void f0(T);
template void f0(int); // okay
template<typename T> void f0(T) { }
// A definition of the class or class template containing a member function
// template shall be in scope at the point of the explicit instantiation of
// the member function template.
struct X0; // expected-note {{forward declaration}}
template<typename> struct X1; // expected-note 5{{declared here}}
template void X0::f0<int>(int); // expected-error {{incomplete type}}
template void X1<int>::f0<int>(int); // expected-error {{implicit instantiation of undefined template}}
// A definition of a class template or class member template shall be in scope
// at the point of the explicit instantiation of the class template or class
// member template.
template struct X1<float>; // expected-error{{explicit instantiation of undefined template}}
template<typename T>
struct X2 { // expected-note 4{{refers here}}
template<typename U>
struct Inner; // expected-note{{declared here}}
struct InnerClass; // expected-note{{forward declaration}}
};
template struct X2<int>::Inner<float>; // expected-error{{explicit instantiation of undefined template}}
// A definition of a class template shall be in scope at the point of an
// explicit instantiation of a member function or a static data member of the
// class template.
template void X1<int>::f1(int); // expected-error {{undefined template}}
template void X1<int>::f1<int>(int); // expected-error {{undefined template}}
template int X1<int>::member; // expected-error {{undefined template}}
// A definition of a member class of a class template shall be in scope at the
// point of an explicit instantiation of the member class.
template struct X2<float>::InnerClass; // expected-error{{undefined member}}
// If the declaration of the explicit instantiation names an implicitly-declared
// special member function (Clause 12), the program is ill-formed.
template X2<int>::X2(); // expected-error{{not an instantiation}}
template X2<int>::X2(const X2&); // expected-error{{not an instantiation}}
template X2<int>::~X2(); // expected-error{{not an instantiation}}
template X2<int> &X2<int>::operator=(const X2<int>&); // expected-error{{not an instantiation}}
// A definition of a class template is sufficient to explicitly
// instantiate a member of the class template which itself is not yet defined.
namespace PR7979 {
template <typename T> struct S {
void f();
static void g();
static int i;
struct S2 {
void h();
};
};
template void S<int>::f();
template void S<int>::g();
template int S<int>::i;
template void S<int>::S2::h();
template <typename T> void S<T>::f() {}
template <typename T> void S<T>::g() {}
template <typename T> int S<T>::i;
template <typename T> void S<T>::S2::h() {}
}
namespace PR11599 {
template <typename STRING_TYPE> class BasicStringPiece; // expected-note {{template is declared here}}
extern template class BasicStringPiece<int>; // expected-error{{explicit instantiation of undefined template 'PR11599::BasicStringPiece<int>}}
template class BasicStringPiece<int>;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p2.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -pedantic -Wc++11-compat %s
// Example from the standard
template<class T> class Array { void mf() { } };
template class Array<char>;
template void Array<int>::mf();
template<class T> void sort(Array<T>& v) { /* ... */ }
template void sort(Array<char>&);
namespace N {
template<class T> void f(T&) { }
}
template void N::f<int>(int&);
template<typename T>
struct X0 {
struct Inner {};
void f() { }
static T value;
};
template<typename T>
T X0<T>::value = 17;
typedef X0<int> XInt;
template struct XInt::Inner; // expected-warning{{template-id}}
template void XInt::f(); // expected-warning{{template-id}}
template int XInt::value; // expected-warning{{template-id}}
namespace N {
template<typename T>
struct X1 { // expected-note{{explicit instantiation refers here}}
};
template<typename T>
void f1(T) {} // expected-note{{explicit instantiation refers here}}
}
using namespace N;
template struct X1<int>; // expected-warning{{must occur in}}
template void f1(int); // expected-warning{{must occur in}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p1-0x.cpp
|
// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
template<typename T>
struct X {
void f() {}
};
template inline void X<int>::f(); // expected-error{{explicit instantiation cannot be 'inline'}}
template<typename T>
struct Y {
constexpr int f() { return 0; } // expected-warning{{C++14}}
};
template constexpr int Y<int>::f() const; // expected-error{{explicit instantiation cannot be 'constexpr'}}
template<typename T>
struct Z {
enum E : T { e1, e2 };
T t; // expected-note {{refers here}}
};
template enum Z<int>::E; // expected-error {{enumerations cannot be explicitly instantiated}}
template int Z<int>::t; // expected-error {{explicit instantiation of 't' does not refer to}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p3-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -verify %s
// expected-no-diagnostics
// If the name declared in the explicit instantiation is an
// unqualified name, the explicit instantiation shall appear in the
// namespace where its template is declared or, if that namespace is
// inline (7.3.1), any namespace from its enclosing namespace set.
namespace has_inline_namespaces {
inline namespace inner {
template<class T> void f(T&) {}
template<class T>
struct X0 {
struct MemberClass {};
void mem_func() {}
template<typename U>
struct MemberClassTemplate {};
template<typename U>
void mem_func_template(U&) {}
static int value;
};
}
template<typename T> int X0<T>::value = 17;
struct X1 {};
struct X2 {};
template void f(X1&);
template void f<X2>(X2&);
template struct X0<X1>;
template struct X0<X2>::MemberClass;
template void X0<X2>::mem_func();
template struct X0<X2>::MemberClassTemplate<X1>;
template void X0<X2>::mem_func_template(X1&);
template int X0<X2>::value;
}
struct X3;
struct X4;
template void has_inline_namespaces::f(X3&);
template void has_inline_namespaces::f<X4>(X4&);
template struct has_inline_namespaces::X0<X3>;
template struct has_inline_namespaces::X0<X4>::MemberClass;
template void has_inline_namespaces::X0<X4>::mem_func();
template
struct has_inline_namespaces::X0<X4>::MemberClassTemplate<X3>;
template
void has_inline_namespaces::X0<X4>::mem_func_template(X3&);
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p1-emit.cpp
|
// RUN: %clang_cc1 -emit-llvm -triple x86_64-apple-darwin10 -o - %s | FileCheck %s
template<typename T>
struct X {
static T member1;
static T member2;
static T member3;
};
template<typename T>
T X<T>::member1;
template<typename T>
T X<T>::member2 = 17;
// CHECK: @_ZN1XIiE7member1E = weak_odr global i32 0
template int X<int>::member1;
// CHECK: @_ZN1XIiE7member2E = weak_odr global i32 17
template int X<int>::member2;
// For implicit instantiation of
long& get(bool Cond1, bool Cond2) {
// CHECK: @_ZN1XIlE7member1E = linkonce_odr global i64 0
// CHECK: @_ZN1XIlE7member2E = linkonce_odr global i64 17
// CHECK: @_ZN1XIlE7member3E = external global i64
return Cond1? X<long>::member1
: Cond2? X<long>::member2
: X<long>::member3;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p1.cpp
|
// 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}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p12.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
namespace test0 {
char* p = 0;
template<class T> T g(T x = &p) { return x; }
template int g<int>(int); // OK even though &p isn't an int.
}
// Don't impose access restrictions on explicit instantiations.
namespace test1 {
class A {
class Private {};
public:
typedef Private Public;
};
template <class T> class Temp {
static Temp<A::Public> make() { return Temp<A::Public>(); }
};
template class Temp<A::Private>;
// FIXME: this ought to be an error, but it isn't because Sema is
// silently failing to create a declaration for the explicit
// instantiation.
template class Temp<A::Private> Temp<int>::make();
}
// Don't impose access restrictions on explicit specializations,
// either. This goes here because it's an extension of the rule for
// explicit instantiations and doesn't have any independent support.
namespace test2 {
class A {
class Private {}; // expected-note {{implicitly declared private here}}
public:
typedef Private Public;
};
template <class T> class Temp {
static Temp<A::Public> make();
};
template <> class Temp<A::Private> {
public:
Temp(int x) {}
};
template <> class Temp<A::Private> Temp<int>::make() { // expected-error {{'Private' is a private member of 'test2::A'}}
return Temp<A::Public>(0);
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p9-linkage.cpp
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin -O1 -disable-llvm-optzns -emit-llvm -std=c++11 -o - %s | FileCheck %s
template<typename T>
struct X0 {
void f(T &t) {
t = 0;
}
void g(T &t);
void h(T &t);
static T static_var;
};
template<typename T>
inline void X0<T>::g(T & t) {
t = 0;
}
template<typename T>
void X0<T>::h(T & t) {
t = 0;
}
template<typename T>
T X0<T>::static_var = 0;
extern template struct X0<int*>;
int *&test(X0<int*> xi, int *ip) {
// CHECK: define available_externally void @_ZN2X0IPiE1fERS0_
xi.f(ip);
// CHECK: define available_externally void @_ZN2X0IPiE1gERS0_
xi.g(ip);
// CHECK: declare void @_ZN2X0IPiE1hERS0_
xi.h(ip);
return X0<int*>::static_var;
}
template<typename T>
void f0(T& t) {
t = 0;
}
template<typename T>
inline void f1(T& t) {
t = 0;
}
extern template void f0<>(int *&);
extern template void f1<>(int *&);
void test_f0(int *ip, float *fp) {
// CHECK: declare void @_Z2f0IPiEvRT_
f0(ip);
// CHECK: define linkonce_odr void @_Z2f0IPfEvRT_
f0(fp);
}
void test_f1(int *ip, float *fp) {
// CHECK: define available_externally void @_Z2f1IPiEvRT_
f1(ip);
// CHECK: define linkonce_odr void @_Z2f1IPfEvRT_
f1(fp);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p5.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -Wc++11-compat %s
namespace N {
template<class T> class Y { // expected-note{{explicit instantiation refers here}}
void mf() { }
};
}
template class Z<int>; // expected-error{{explicit instantiation of non-template class 'Z'}}
// FIXME: This example from the standard is wrong; note posted to CWG reflector
// on 10/27/2009
using N::Y;
template class Y<int>; // expected-warning{{must occur in}}
template class N::Y<char*>;
template void N::Y<double>::mf();
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p11.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
class X {
template <typename T> class Y {};
};
class A {
class B {};
class C {};
};
// C++0x [temp.explicit] 14.7.2/11:
// The usual access checking rules do not apply to names used to specify
// explicit instantiations.
template class X::Y<A::B>;
// As an extension, this rule is applied to explicit specializations as well.
template <> class X::Y<A::C> {};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.explicit/p6.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { }
// instantiate sort(Array<int>&) - template-argument deduced
template void sort<>(Array<int>&);
template void sort(Array<long>&);
template<typename T, typename U> void f0(T, U*) { }
template void f0<int>(int, float*);
template void f0<>(double, float*);
template<typename T> struct hash { };
struct S {
bool operator==(const S&) const { return false; }
};
template<typename T> struct Hash_map {
void Method(const T& x) { h(x); }
hash<T> h;
};
Hash_map<S> *x;
const Hash_map<S> *foo() {
return x;
}
template<> struct hash<S> {
int operator()(const S& k) const {
return 0;
}
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p2-0x.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s -Wno-c++1y-extensions
// This test creates cases where implicit instantiations of various entities
// would cause a diagnostic, but provides expliict specializations for those
// entities that avoid the diagnostic. The specializations are alternately
// declarations and definitions, and the intent of this test is to verify
// that we allow specializations only in the appropriate namespaces (and
// nowhere else).
struct NonDefaultConstructible {
NonDefaultConstructible(int);
};
// FIXME: The "must originally be declared in namespace" diagnostics throughout
// this file are wrong.
// C++ [temp.expl.spec]p1:
// An explicit specialization of any of the following:
// -- function template
namespace N0 {
template<typename T> void f0(T) {
T t;
}
template<> void f0(NonDefaultConstructible) { }
void test_f0(NonDefaultConstructible NDC) {
f0(NDC);
}
template<> void f0(int);
template<> void f0(long);
}
template<> void N0::f0(int) { } // okay
namespace N1 {
template<> void N0::f0(long) { } // expected-error{{does not enclose namespace}}
}
template<> void N0::f0(double) { }
struct X1 {
template<typename T> void f(T);
template<> void f(int); // expected-error{{in class scope}}
};
// -- class template
namespace N0 {
template<typename T>
struct X0 { // expected-note {{here}}
static T member;
void f1(T t) {
t = 17;
}
struct Inner : public T { }; // expected-note 2{{here}}
template<typename U>
struct InnerTemplate : public T { }; // expected-note 1{{explicitly specialized}} \
// expected-error{{base specifier}}
template<typename U>
void ft1(T t, U u);
};
}
template<typename T>
template<typename U>
void N0::X0<T>::ft1(T t, U u) {
t = u;
}
template<typename T> T N0::X0<T>::member;
template<> struct N0::X0<void> { };
N0::X0<void> test_X0;
namespace N1 {
template<> struct N0::X0<const void> { }; // expected-error{{class template specialization of 'X0' not in a namespace enclosing 'N0'}}
}
namespace N0 {
template<> struct X0<volatile void>;
}
template<> struct N0::X0<volatile void> {
void f1(void *);
};
// -- variable template [C++1y]
namespace N0 {
template<typename T> int v0; // expected-note +{{here}}
template<> extern int v0<char[1]>;
template<> extern int v0<char[2]>;
template<> extern int v0<char[5]>;
template<> extern int v0<char[6]>;
}
using N0::v0;
template<typename T> int v1; // expected-note +{{here}}
template<> extern int v1<char[3]>;
template<> extern int v1<char[4]>;
template<> extern int v1<char[7]>;
template<> extern int v1<char[8]>;
template<> int N0::v0<int[1]>;
template<> int v0<int[2]>; // FIXME: ill-formed
template<> int ::v1<int[3]>; // expected-warning {{extra qualification}}
template<> int v1<int[4]>;
template<> int N0::v0<char[1]>;
template<> int v0<char[2]>; // FIXME: ill-formed
template<> int ::v1<char[3]>; // expected-warning {{extra qualification}}
template<> int v1<char[4]>;
namespace N1 {
template<> int N0::v0<int[5]>; // expected-error {{must originally be declared in namespace 'N0'}} expected-error {{does not enclose namespace}}
template<> int v0<int[6]>; // expected-error {{must originally be declared in namespace 'N0'}}
template<> int ::v1<int[7]>; // expected-error {{must originally be declared in the global scope}} expected-error {{cannot name the global scope}}
template<> int v1<int[8]>; // expected-error {{must originally be declared in the global scope}}
template<> int N0::v0<char[5]>; // expected-error {{does not enclose namespace 'N0'}}
template<> int v0<char[6]>; // FIXME: ill-formed
template<> int ::v1<char[7]>; // expected-error {{cannot name the global scope}}
template<> int v1<char[8]>; // FIXME: ill-formed
}
// -- member function of a class template
template<> void N0::X0<void*>::f1(void *) { }
void test_spec(N0::X0<void*> xvp, void *vp) {
xvp.f1(vp);
}
namespace N0 {
template<> void X0<volatile void>::f1(void *) { } // expected-error{{no function template matches}}
template<> void X0<const volatile void*>::f1(const volatile void*);
}
void test_x0_cvvoid(N0::X0<const volatile void*> x0, const volatile void *cvp) {
x0.f1(cvp); // okay: we've explicitly specialized
}
// -- static data member of a class template
namespace N0 {
// This actually tests p15; the following is a declaration, not a definition.
template<>
NonDefaultConstructible X0<NonDefaultConstructible>::member;
template<> long X0<long>::member = 17;
template<> float X0<float>::member;
template<> double X0<double>::member;
}
NonDefaultConstructible &get_static_member() {
return N0::X0<NonDefaultConstructible>::member;
}
template<> int N0::X0<int>::member;
template<> float N0::X0<float>::member = 3.14f;
namespace N1 {
template<> double N0::X0<double>::member = 3.14; // expected-error{{does not enclose namespace}}
}
// -- member class of a class template
namespace N0 {
template<>
struct X0<void*>::Inner { };
template<>
struct X0<int>::Inner { };
template<>
struct X0<unsigned>::Inner;
template<>
struct X0<float>::Inner;
template<>
struct X0<double>::Inner; // expected-note{{forward declaration}}
}
template<>
struct N0::X0<long>::Inner { };
template<>
struct N0::X0<float>::Inner { };
namespace N1 {
template<>
struct N0::X0<unsigned>::Inner { }; // expected-error{{member class specialization}}
template<>
struct N0::X0<unsigned long>::Inner { }; // expected-error{{member class specialization}}
};
N0::X0<void*>::Inner inner0;
N0::X0<int>::Inner inner1;
N0::X0<long>::Inner inner2;
N0::X0<float>::Inner inner3;
N0::X0<double>::Inner inner4; // expected-error{{incomplete}}
// -- member class template of a class template
namespace N0 {
template<>
template<>
struct X0<void*>::InnerTemplate<int> { };
template<> template<>
struct X0<int>::InnerTemplate<int>; // expected-note{{forward declaration}}
template<> template<>
struct X0<int>::InnerTemplate<long>;
template<> template<>
struct X0<int>::InnerTemplate<double>;
}
template<> template<>
struct N0::X0<int>::InnerTemplate<long> { }; // okay
template<> template<>
struct N0::X0<int>::InnerTemplate<float> { };
namespace N1 {
template<> template<>
struct N0::X0<int>::InnerTemplate<double> { }; // expected-error{{enclosing}}
}
N0::X0<void*>::InnerTemplate<int> inner_template0;
N0::X0<int>::InnerTemplate<int> inner_template1; // expected-error{{incomplete}}
N0::X0<int>::InnerTemplate<long> inner_template2;
N0::X0<int>::InnerTemplate<unsigned long> inner_template3; // expected-note{{instantiation}}
// -- member function template of a class template
namespace N0 {
template<>
template<>
void X0<void*>::ft1(void*, const void*) { }
template<> template<>
void X0<void*>::ft1(void *, int);
template<> template<>
void X0<void*>::ft1(void *, unsigned);
template<> template<>
void X0<void*>::ft1(void *, long);
}
template<> template<>
void N0::X0<void*>::ft1(void *, unsigned) { } // okay
template<> template<>
void N0::X0<void*>::ft1(void *, float) { }
namespace N1 {
template<> template<>
void N0::X0<void*>::ft1(void *, long) { } // expected-error{{does not enclose namespace}}
}
void test_func_template(N0::X0<void *> xvp, void *vp, const void *cvp,
int i, unsigned u) {
xvp.ft1(vp, cvp);
xvp.ft1(vp, i);
xvp.ft1(vp, u);
}
namespace has_inline_namespaces {
inline namespace inner {
template<class T> void f(T&);
template<class T>
struct X0 {
struct MemberClass;
void mem_func();
template<typename U>
struct MemberClassTemplate;
template<typename U>
void mem_func_template(U&);
static int value;
};
}
struct X1;
struct X2;
// An explicit specialization whose declarator-id is not qualified
// shall be declared in the nearest enclosing namespace of the
// template, or, if the namespace is inline (7.3.1), any namespace
// from its enclosing namespace set.
template<> void f(X1&);
template<> void f<X2>(X2&);
template<> struct X0<X1> { };
template<> struct X0<X2>::MemberClass { };
template<> void X0<X2>::mem_func();
template<> template<typename T> struct X0<X2>::MemberClassTemplate { };
template<> template<typename T> void X0<X2>::mem_func_template(T&) { }
template<> int X0<X2>::value = 12;
}
struct X3;
struct X4;
template<> void has_inline_namespaces::f(X3&);
template<> void has_inline_namespaces::f<X4>(X4&);
template<> struct has_inline_namespaces::X0<X3> { };
template<> struct has_inline_namespaces::X0<X4>::MemberClass { };
template<> void has_inline_namespaces::X0<X4>::mem_func();
template<> template<typename T>
struct has_inline_namespaces::X0<X4>::MemberClassTemplate { };
template<> template<typename T>
void has_inline_namespaces::X0<X4>::mem_func_template(T&) { }
template<> int has_inline_namespaces::X0<X4>::value = 13;
namespace PR12938 {
template<typename> [[noreturn]] void func();
template<> void func<int>();
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p9.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
namespace N {
template<class T> class X { /* ... */ };
template<class T> class Y { /* ... */ };
template<> class X<int> { /* ... */ };
template<> class Y<double>;
const unsigned NumElements = 17;
}
template<> class N::Y<double> {
int array[NumElements];
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p16.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class T> struct A {
void f(T);
template<class X1> void g1(T, X1);
template<class X2> void g2(T, X2);
void h(T) { }
};
// specialization
template<> void A<int>::f(int);
// out of class member template definition
template<class T> template<class X1> void A<T>::g1(T, X1) { }
// member template specialization
template<> template<class X1> void A<int>::g1(int, X1);
// member template specialization
template<> template<>
void A<int>::g1(int, char); // X1 deduced as char
template<> template<>
void A<int>::g2<char>(int, char); // X2 specified as char
// member specialization even if defined in class definition
template<> void A<int>::h(int) { }
namespace PR10024 {
template <typename T>
struct Test{
template <typename U>
void get(U i) {}
};
template <typename T>
template <>
void Test<T>::get<double>(double i) {} // expected-error{{cannot specialize (with 'template<>') a member of an unspecialized template}}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p14.cpp
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin -emit-llvm -o - %s | FileCheck %s
template<class T> void f(T) { /* ... */ }
template<class T> inline void g(T) { /* ... */ }
// CHECK: define void @_Z1gIiEvT_
template<> void g<>(int) { /* ... */ }
template<class T>
struct X {
void f() { }
void g();
void h();
};
template<class T>
void X<T>::g() {
}
template<class T>
inline void X<T>::h() {
}
// CHECK: define void @_ZN1XIiE1fEv
template<> void X<int>::f() { }
// CHECK: define void @_ZN1XIiE1hEv
template<> void X<int>::h() { }
// CHECK: define linkonce_odr void @_Z1fIiEvT_
template<> inline void f<>(int) { /* ... */ }
// CHECK: define linkonce_odr void @_ZN1XIiE1gEv
template<> inline void X<int>::g() { }
void test(X<int> xi) {
f(17);
g(17);
xi.f();
xi.g();
xi.h();
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p21.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
struct X {
void mf1(T);
template<typename U> void mf2(T, U); // expected-note{{previous}}
};
template<>
void X<int>::mf1(int i = 17) // expected-error{{default}}
{
}
template<> template<>
void X<int>::mf2(int, int = 17) // expected-error{{default}}
{ }
template<> template<typename U>
void X<int>::mf2(int, U = U()) // expected-error{{default}}
{
}
template<>
struct X<float> {
void mf1(float);
};
void X<float>::mf1(float = 3.14f) // okay
{
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p5-example.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class T> struct A {
struct B { };
template<class U> struct C { };
};
template<> struct A<int> {
void f(int);
};
void h() {
A<int> a;
a.f(16);
}
// A<int>::f must be defined somewhere
// template<> not used for a member of an // explicitly specialized class template
void A<int>::f(int) { /* ... */ }
template<> struct A<char>::B {
void f();
};
// template<> also not used when defining a member of // an explicitly specialized member class
void A<char>::B::f() { /* ... */ }
template<> template<class U> struct A<char>::C {
void f();
};
template<>
template<class U> void A<char>::C<U>::f() { /* ... */ }
template<> struct A<short>::B {
void f();
};
template<> void A<short>::B::f() { /* ... */ } // expected-error{{no function template matches function template specialization 'f'}}
template<> template<class U> struct A<short>::C {
void f();
};
template<class U> void A<short>::C<U>::f() { /* ... */ } // expected-error{{template parameter list matching the non-templated nested type 'A<short>' should be empty ('template<>')}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p20.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
void f(T);
template<typename T>
struct A { };
struct X {
template<> friend void f<int>(int); // expected-error{{in a friend}}
template<> friend class A<int>; // expected-error{{cannot be a friend}}
friend void f<float>(float); // okay
friend class A<float>; // okay
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p10.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class T> class X;
template<> class X<int>; // expected-note{{forward}}
X<int>* p;
X<int> x; // expected-error{{incomplete type}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p4.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
struct IntHolder { // expected-note{{here}} // expected-note 2{{candidate constructor (the implicit copy constructor)}}
IntHolder(int); // expected-note 2{{candidate constructor}}
};
template<typename T, typename U>
struct X { // expected-note{{here}}
void f() {
T t; // expected-error{{no matching}}
}
void g() { }
struct Inner { // expected-error{{implicit default}}
T value; // expected-note {{member is declared here}}
};
static T value;
};
template<typename T, typename U>
T X<T, U>::value; // expected-error{{no matching constructor}}
IntHolder &test_X_IntHolderInt(X<IntHolder, int> xih) {
xih.g(); // okay
xih.f(); // expected-note{{instantiation}}
X<IntHolder, int>::Inner inner; // expected-note {{first required here}}
return X<IntHolder, int>::value; // expected-note{{instantiation}}
}
// Explicitly specialize the members of X<IntHolder, long> to not cause
// problems with instantiation.
template<>
void X<IntHolder, long>::f() { }
template<>
struct X<IntHolder, long>::Inner {
Inner() : value(17) { }
IntHolder value;
};
template<>
IntHolder X<IntHolder, long>::value = 17;
IntHolder &test_X_IntHolderInt(X<IntHolder, long> xih) {
xih.g(); // okay
xih.f(); // okay, uses specialization
X<IntHolder, long>::Inner inner; // okay, uses specialization
return X<IntHolder, long>::value; // okay, uses specialization
}
template<>
X<IntHolder, long>::X() { } // expected-error{{instantiated member}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p13.cpp
|
// RUN: %clang_cc1 -fsyntax-only %s
template<typename T> void f(T);
template<> void f(int) { }
void f(int) { }
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p15.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
struct NonDefaultConstructible {
NonDefaultConstructible(const NonDefaultConstructible&); // expected-note{{candidate constructor}}
};
template<typename T, typename U>
struct X {
static T member;
};
template<typename T, typename U>
T X<T, U>::member; // expected-error{{no matching constructor}}
// Okay; this is a declaration, not a definition.
template<>
NonDefaultConstructible X<NonDefaultConstructible, long>::member;
NonDefaultConstructible &test(bool b) {
return b? X<NonDefaultConstructible, int>::member // expected-note{{instantiation}}
: X<NonDefaultConstructible, long>::member;
}
namespace rdar9422013 {
template<int>
struct X {
struct Inner {
static unsigned array[17];
};
};
template<> unsigned X<1>::Inner::array[]; // okay
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p3.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
namespace N {
template<class T> class X; // expected-note {{'N::X' declared here}} \
// expected-note {{explicitly specialized declaration is here}}
}
// TODO: Don't add a namespace qualifier to the template if it would trigger
// the warning about the specialization being outside of the namespace.
template<> class X<int> { /* ... */ }; // expected-error {{no template named 'X'; did you mean 'N::X'?}} \
// expected-warning {{first declaration of class template specialization of 'X' outside namespace 'N' is a C++11 extension}}
namespace N {
template<> class X<char*> { /* ... */ }; // OK: X is a template
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p2.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// This test creates cases where implicit instantiations of various entities
// would cause a diagnostic, but provides expliict specializations for those
// entities that avoid the diagnostic. The specializations are alternately
// declarations and definitions, and the intent of this test is to verify
// that we allow specializations only in the appropriate namespaces (and
// nowhere else).
struct NonDefaultConstructible {
NonDefaultConstructible(int);
};
// C++ [temp.expl.spec]p1:
// An explicit specialization of any of the following:
// -- function template
namespace N0 {
template<typename T> void f0(T) { // expected-note{{here}}
T t;
}
template<> void f0(NonDefaultConstructible) { }
void test_f0(NonDefaultConstructible NDC) {
f0(NDC);
}
template<> void f0(int);
template<> void f0(long);
}
template<> void N0::f0(int) { } // okay
namespace N1 {
template<> void N0::f0(long) { } // expected-error{{does not enclose namespace}}
}
template<> void N0::f0(double); // expected-warning{{C++11 extension}}
template<> void N0::f0(double) { }
struct X1 {
template<typename T> void f(T);
template<> void f(int); // expected-error{{in class scope}}
};
// -- class template
namespace N0 {
template<typename T>
struct X0 { // expected-note 2{{here}}
static T member; // expected-note{{here}}
void f1(T t) { // expected-note{{explicitly specialized declaration is here}}
t = 17;
}
struct Inner : public T { }; // expected-note 3{{here}}
template<typename U>
struct InnerTemplate : public T { }; // expected-note 2{{explicitly specialized}} \
// expected-error{{base specifier}}
template<typename U>
void ft1(T t, U u); // expected-note{{explicitly specialized}}
};
}
template<typename T>
template<typename U>
void N0::X0<T>::ft1(T t, U u) {
t = u;
}
template<typename T> T N0::X0<T>::member;
template<> struct N0::X0<void> { }; // expected-warning{{C++11 extension}}
N0::X0<void> test_X0;
namespace N1 {
template<> struct N0::X0<const void> { }; // expected-error{{not in a namespace enclosing 'N0'}}
}
namespace N0 {
template<> struct X0<volatile void>;
}
template<> struct N0::X0<volatile void> {
void f1(void *);
};
// -- member function of a class template
template<> void N0::X0<void*>::f1(void *) { } // expected-warning{{member function specialization}}
void test_spec(N0::X0<void*> xvp, void *vp) {
xvp.f1(vp);
}
namespace N0 {
template<> void X0<volatile void>::f1(void *) { } // expected-error{{no function template matches}}
template<> void X0<const volatile void*>::f1(const volatile void*);
}
void test_x0_cvvoid(N0::X0<const volatile void*> x0, const volatile void *cvp) {
x0.f1(cvp); // okay: we've explicitly specialized
}
// -- static data member of a class template
namespace N0 {
// This actually tests p15; the following is a declaration, not a definition.
template<>
NonDefaultConstructible X0<NonDefaultConstructible>::member;
template<> long X0<long>::member = 17;
template<> float X0<float>::member;
template<> double X0<double>::member;
}
NonDefaultConstructible &get_static_member() {
return N0::X0<NonDefaultConstructible>::member;
}
template<> int N0::X0<int>::member; // expected-warning{{C++11 extension}}
template<> float N0::X0<float>::member = 3.14f;
namespace N1 {
template<> double N0::X0<double>::member = 3.14; // expected-error{{does not enclose namespace}}
}
// -- member class of a class template
namespace N0 {
template<>
struct X0<void*>::Inner { };
template<>
struct X0<int>::Inner { };
template<>
struct X0<unsigned>::Inner;
template<>
struct X0<float>::Inner;
template<>
struct X0<double>::Inner; // expected-note{{forward declaration}}
}
template<>
struct N0::X0<long>::Inner { }; // expected-warning{{C++11 extension}}
template<>
struct N0::X0<float>::Inner { };
namespace N1 {
template<>
struct N0::X0<unsigned>::Inner { }; // expected-error{{member class specialization}}
template<>
struct N0::X0<unsigned long>::Inner { }; // expected-error{{member class specialization}}
};
N0::X0<void*>::Inner inner0;
N0::X0<int>::Inner inner1;
N0::X0<long>::Inner inner2;
N0::X0<float>::Inner inner3;
N0::X0<double>::Inner inner4; // expected-error{{incomplete}}
// -- member class template of a class template
namespace N0 {
template<>
template<>
struct X0<void*>::InnerTemplate<int> { };
template<> template<>
struct X0<int>::InnerTemplate<int>; // expected-note{{forward declaration}}
template<> template<>
struct X0<int>::InnerTemplate<long>;
template<> template<>
struct X0<int>::InnerTemplate<double>;
}
template<> template<>
struct N0::X0<int>::InnerTemplate<long> { }; // okay
template<> template<>
struct N0::X0<int>::InnerTemplate<float> { }; // expected-warning{{class template specialization}}
namespace N1 {
template<> template<>
struct N0::X0<int>::InnerTemplate<double> { }; // expected-error{{enclosing}}
}
N0::X0<void*>::InnerTemplate<int> inner_template0;
N0::X0<int>::InnerTemplate<int> inner_template1; // expected-error{{incomplete}}
N0::X0<int>::InnerTemplate<long> inner_template2;
N0::X0<int>::InnerTemplate<unsigned long> inner_template3; // expected-note{{instantiation}}
// -- member function template of a class template
namespace N0 {
template<>
template<>
void X0<void*>::ft1(void*, const void*) { }
template<> template<>
void X0<void*>::ft1(void *, int);
template<> template<>
void X0<void*>::ft1(void *, unsigned);
template<> template<>
void X0<void*>::ft1(void *, long);
}
template<> template<>
void N0::X0<void*>::ft1(void *, unsigned) { } // okay
template<> template<>
void N0::X0<void*>::ft1(void *, float) { } // expected-warning{{function template specialization}}
namespace N1 {
template<> template<>
void N0::X0<void*>::ft1(void *, long) { } // expected-error{{does not enclose namespace}}
}
void test_func_template(N0::X0<void *> xvp, void *vp, const void *cvp,
int i, unsigned u) {
xvp.ft1(vp, cvp);
xvp.ft1(vp, i);
xvp.ft1(vp, u);
}
namespace PR8979 {
template<typename Z>
struct X0 {
template <class T, class U> class Inner;
struct OtherInner;
template<typename T, typename U> void f(Inner<T, U>&);
typedef Inner<OtherInner, OtherInner> MyInner;
template<> void f(MyInner&); // expected-error{{cannot specialize a function 'f' within class scope}}
};
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
// This test creates cases where implicit instantiations of various entities
// would cause a diagnostic, but provides expliict specializations for those
// entities that avoid the diagnostic. The intent is to verify that
// implicit instantiations do not occur (because the explicit specialization
// is used instead).
struct NonDefaultConstructible {
NonDefaultConstructible(int);
};
// C++ [temp.expl.spec]p1:
// An explicit specialization of any of the following:
// -- function template
template<typename T> void f0(T) {
T t;
}
template<> void f0(NonDefaultConstructible) { }
void test_f0(NonDefaultConstructible NDC) {
f0(NDC);
}
// -- class template
template<typename T>
struct X0 {
static T member;
void f1(T t) {
t = 17;
}
struct Inner : public T { };
template<typename U>
struct InnerTemplate : public T { };
template<typename U>
void ft1(T t, U u);
};
template<typename T>
template<typename U>
void X0<T>::ft1(T t, U u) {
t = u;
}
template<typename T> T X0<T>::member;
template<> struct X0<void> { };
X0<void> test_X0;
// -- member function of a class template
template<> void X0<void*>::f1(void *) { }
void test_spec(X0<void*> xvp, void *vp) {
xvp.f1(vp);
}
// -- static data member of a class template
template<>
NonDefaultConstructible X0<NonDefaultConstructible>::member = 17;
NonDefaultConstructible &get_static_member() {
return X0<NonDefaultConstructible>::member;
}
// -- member class of a class template
template<>
struct X0<void*>::Inner { };
X0<void*>::Inner inner0;
// -- member class template of a class template
template<>
template<>
struct X0<void*>::InnerTemplate<int> { };
X0<void*>::InnerTemplate<int> inner_template0;
// -- member function template of a class template
template<>
template<>
void X0<void*>::ft1(void*, const void*) { }
void test_func_template(X0<void *> xvp, void *vp, const void *cvp) {
xvp.ft1(vp, cvp);
}
// example from the standard:
template<class T> class stream;
template<> class stream<char> { /* ... */ };
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }
template<> void sort<char*>(Array<char*>&) ;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p5.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
struct IntHolder {
IntHolder(int);
};
template<typename T, typename U>
struct X {
void f() {
T t;
}
void g() { }
struct Inner {
T value;
};
static T value;
};
template<typename T, typename U>
T X<T, U>::value;
// Explicitly specialize the members of X<IntHolder, long> to not cause
// problems with instantiation, but only provide declarations (not definitions).
template<>
void X<IntHolder, long>::f();
template<>
struct X<IntHolder, long>::Inner; // expected-note{{forward declaration}}
template<>
IntHolder X<IntHolder, long>::value;
IntHolder &test_X_IntHolderInt(X<IntHolder, long> xih) {
xih.g(); // okay
xih.f(); // okay, uses specialization
X<IntHolder, long>::Inner inner; // expected-error {{incomplete}}
return X<IntHolder, long>::value; // okay, uses specialization
}
template<class T> struct A {
void f(T) { /* ... */ }
};
template<> struct A<int> {
void f(int);
};
void h() {
A<int> a;
a.f(16); // A<int>::f must be defined somewhere
}
// explicit specialization syntax not used for a member of
// explicitly specialized class template specialization
void A<int>::f(int) { /* ... */ }
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p17.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class T1>
class A {
template<class T2> class B {
void mf();
};
};
template<> template<> class A<int>::B<double>;
template<> template<> void A<char>::B<char>::mf();
template<> void A<char>::B<int>::mf(); // expected-error{{requires 'template<>'}}
namespace test1 {
template <class> class A {
static int foo;
static int bar;
};
typedef A<int> AA;
template <> int AA::foo = 0;
int AA::bar = 1; // expected-error {{template specialization requires 'template<>'}}
int A<float>::bar = 2; // expected-error {{template specialization requires 'template<>'}}
template <> class A<double> {
public:
static int foo;
static int bar;
};
typedef A<double> AB;
template <> int AB::foo = 0; // expected-error{{extraneous 'template<>'}}
int AB::bar = 1;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p19.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
struct X {
template<typename U> struct Inner { };
template<typename U> void f(T, U) { }
};
template<> template<typename U>
struct X<int>::Inner {
U member;
};
template<> template<typename U>
void X<int>::f(int x, U y) {
x = y; // expected-error{{incompatible type}}
}
void test(X<int> xi, X<long> xl, float *fp) {
X<int>::Inner<float*> xii;
xii.member = fp;
xi.f(17, 25);
xi.f(17, 3.14159);
xi.f(17, fp); // expected-note{{instantiation}}
X<long>::Inner<float*> xli;
xli.member = fp; // expected-error{{no member}}
xl.f(17, fp); // okay
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p11.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v);
// explicit specialization for sort(Array<int>&)
// with deduced template-argument of type int
template<> void sort(Array<int>&);
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/examples.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
namespace PR5907 {
template<typename T> struct identity { typedef T type; };
struct A { A(); };
identity<A>::type::A() { }
struct B { void f(); };
template<typename T> struct C { typedef B type; };
void C<int>::type::f() { }
}
namespace PR9421 {
namespace N { template<typename T> struct S { void f(); }; }
typedef N::S<int> T;
namespace N { template<> void T::f() {} }
}
namespace PR8277 {
template< typename S >
struct C
{
template< int >
void F( void )
{
}
};
template< typename S >
struct D
{
typedef C< int > A;
};
typedef D< int >::A A;
template<>
template<>
void A::F< 0 >( void )
{
}
}
namespace PR8277b {
template<typename S> struct C {
void f();
};
template<typename S> struct D {
typedef C<int> A;
};
template<> void D<int>::A::f() {
}
}
namespace PR8708 {
template<typename T> struct A {
template<typename U> struct B {
// #2
void f();
};
};
// #A specialize the member template for
// implicit instantiation of A<int>,
// leaving the member template "unspecialized"
// (14.7.3/16). Specialization uses the syntax
// for explicit specialization (14.7.3/14)
template<> template<typename U>
struct A<int>::B {
// #1
void g();
};
// #1 define its function g. There is an enclosing
// class template, so we write template<> for each
// specialized template (14.7.3/15).
template<> template<typename U>
void A<int>::B<U>::g() { }
// #2 define the unspecialized member template's
// f
template<typename T> template<typename U>
void A<T>::B<U>::f() { }
// specialize the member template again, now
// specializing the member too. This specializes
// #A
template<> template<>
struct A<int>::B<int> {
// #3
void h();
};
// defines #3. There is no enclosing class template, so
// we write no "template<>".
void A<int>::B<int>::h() { }
void test() {
// calls #1
A<int>::B<float> a; a.g();
// calls #2
A<float>::B<int> b; b.f();
// calls #3
A<int>::B<int> c; c.h();
}
}
namespace PR9482 {
namespace N1 {
template <typename T> struct S {
void foo() {}
};
}
namespace N2 {
typedef N1::S<int> X;
}
namespace N1 {
template<> void N2::X::foo() {}
}
}
namespace PR9668 {
namespace First
{
template<class T>
class Bar
{
protected:
static const bool static_bool;
};
}
namespace Second
{
class Foo;
}
typedef First::Bar<Second::Foo> Special;
namespace
First
{
template<>
const bool Special::static_bool(false);
}
}
namespace PR9877 {
template<int>
struct X
{
struct Y;
};
template<> struct X<0>::Y { static const int Z = 1; };
template<> struct X<1>::Y { static const int Z = 1; };
const int X<0>::Y::Z;
template<> const int X<1>::Y::Z; // expected-error{{extraneous 'template<>' in declaration of variable 'Z'}}
}
namespace PR9913 {
template<class,class=int>struct S;
template<class X>struct S<X> {
template<class T> class F;
};
template<class A>
template<class B>
class S<A>::F{};
}
namespace template_class_spec_perClassDecl_nested
{
template <typename T1> struct A {
template <typename T2> struct B {
template <typename T3> struct C {
static void foo();
};
};
};
template <> struct A<int> {
template <typename T2> struct B {
template <typename T3> struct C {
static void foo();
};
};
};
template <> template <typename T3> struct A<int>::B<int>::C {
static void foo();
};
template <> template <> struct A<int>::B<int>::C<int> {
static void foo();
};
template <> template<> template <typename T2> struct A<bool>::B<bool>::C {
static void foo();
};
}
namespace spec_vs_expl_inst {
// Test all permutations of Specialization,
// explicit instantiation Declaration, and explicit instantiation defInition.
namespace SDI { // PR11558
template <typename STRING_TYPE> class BasicStringPiece;
template <> class BasicStringPiece<int> { };
extern template class BasicStringPiece<int>;
template class BasicStringPiece<int>;
}
namespace SID {
template <typename STRING_TYPE> class BasicStringPiece;
template <> class BasicStringPiece<int> { };
template class BasicStringPiece<int>; // expected-note {{explicit instantiation definition is here}}
extern template class BasicStringPiece<int>; // expected-error {{explicit instantiation declaration (with 'extern') follows explicit instantiation definition (without 'extern')}}
}
namespace ISD {
template <typename STRING_TYPE> class BasicStringPiece; // expected-note {{template is declared here}}
template class BasicStringPiece<int>; // expected-error {{explicit instantiation of undefined template 'spec_vs_expl_inst::ISD::BasicStringPiece<int>'}}
template <> class BasicStringPiece<int> { };
extern template class BasicStringPiece<int>;
}
namespace IDS {
template <typename STRING_TYPE> class BasicStringPiece; // expected-note {{template is declared here}}
template class BasicStringPiece<int>; // expected-error {{explicit instantiation of undefined template 'spec_vs_expl_inst::IDS::BasicStringPiece<int>'}} // expected-note {{explicit instantiation definition is here}}
extern template class BasicStringPiece<int>; // expected-error {{explicit instantiation declaration (with 'extern') follows explicit instantiation definition (without 'extern')}}
template <> class BasicStringPiece<int> { };
}
namespace DIS {
template <typename STRING_TYPE> class BasicStringPiece; // expected-note {{template is declared here}}
extern template class BasicStringPiece<int>; // expected-error {{explicit instantiation of undefined template 'spec_vs_expl_inst::DIS::BasicStringPiece<int>'}}
template class BasicStringPiece<int>;
template <> class BasicStringPiece<int> { };
}
namespace DSI {
template <typename STRING_TYPE> class BasicStringPiece; // expected-note {{template is declared here}}
extern template class BasicStringPiece<int>; // expected-error {{explicit instantiation of undefined template 'spec_vs_expl_inst::DSI::BasicStringPiece<int>'}}
template <> class BasicStringPiece<int> { };
template class BasicStringPiece<int>;
}
// The same again, with a defined template class.
namespace SDI_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
template <> class BasicStringPiece<int> { };
extern template class BasicStringPiece<int>;
template class BasicStringPiece<int>;
}
namespace SID_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
template <> class BasicStringPiece<int> { };
template class BasicStringPiece<int>; // expected-note {{explicit instantiation definition is here}}
extern template class BasicStringPiece<int>; // expected-error {{explicit instantiation declaration (with 'extern') follows explicit instantiation definition (without 'extern')}}
}
namespace ISD_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
template class BasicStringPiece<int>; // expected-note {{explicit instantiation first required here}}
template <> class BasicStringPiece<int> { }; // expected-error {{explicit specialization of 'spec_vs_expl_inst::ISD_WithDefinedTemplate::BasicStringPiece<int>' after instantiation}}
extern template class BasicStringPiece<int>;
}
namespace IDS_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
template class BasicStringPiece<int>; // expected-note {{explicit instantiation definition is here}} expected-note {{previous definition is here}}
extern template class BasicStringPiece<int>; // expected-error {{explicit instantiation declaration (with 'extern') follows explicit instantiation definition (without 'extern')}}
template <> class BasicStringPiece<int> { }; // expected-error {{redefinition of 'spec_vs_expl_inst::IDS_WithDefinedTemplate::BasicStringPiece<int>'}}
}
namespace DIS_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
extern template class BasicStringPiece<int>; // expected-note {{explicit instantiation first required here}}
template class BasicStringPiece<int>;
template <> class BasicStringPiece<int> { }; // expected-error {{explicit specialization of 'spec_vs_expl_inst::DIS_WithDefinedTemplate::BasicStringPiece<int>' after instantiation}}
}
namespace DSI_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
extern template class BasicStringPiece<int>; // expected-note {{explicit instantiation first required here}}
template <> class BasicStringPiece<int> { }; // expected-error {{explicit specialization of 'spec_vs_expl_inst::DSI_WithDefinedTemplate::BasicStringPiece<int>' after instantiation}}
template class BasicStringPiece<int>;
}
// And some more random tests.
namespace SII_WithDefinedTemplate {
template <typename STRING_TYPE> class BasicStringPiece {};
template <> class BasicStringPiece<int> { };
template class BasicStringPiece<int>; // expected-note {{previous explicit instantiation is here}}
template class BasicStringPiece<int>; // expected-error {{duplicate explicit instantiation of 'BasicStringPiece<int>'}}
}
namespace SIS {
template <typename STRING_TYPE> class BasicStringPiece;
template <> class BasicStringPiece<int> { }; // expected-note {{previous definition is here}}
template class BasicStringPiece<int>;
template <> class BasicStringPiece<int> { }; // expected-error {{redefinition of 'spec_vs_expl_inst::SIS::BasicStringPiece<int>'}}
}
namespace SDS {
template <typename STRING_TYPE> class BasicStringPiece;
template <> class BasicStringPiece<int> { }; // expected-note {{previous definition is here}}
extern template class BasicStringPiece<int>;
template <> class BasicStringPiece<int> { }; // expected-error {{redefinition of 'spec_vs_expl_inst::SDS::BasicStringPiece<int>'}}
}
namespace SDIS {
template <typename STRING_TYPE> class BasicStringPiece;
template <> class BasicStringPiece<int> { }; // expected-note {{previous definition is here}}
extern template class BasicStringPiece<int>;
template class BasicStringPiece<int>;
template <> class BasicStringPiece<int> { }; // expected-error {{redefinition of 'spec_vs_expl_inst::SDIS::BasicStringPiece<int>'}}
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p6.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T>
struct X0 {
void f();
template<typename U>
void g(U);
struct Nested {
};
static T member;
};
int &use_X0_int(X0<int> x0i, // expected-note{{implicit instantiation first required here}}
int i) {
x0i.f(); // expected-note{{implicit instantiation first required here}}
x0i.g(i); // expected-note{{implicit instantiation first required here}}
X0<int>::Nested nested; // expected-note{{implicit instantiation first required here}}
return X0<int>::member; // expected-note{{implicit instantiation first required here}}
}
template<>
void X0<int>::f() { // expected-error{{after instantiation}}
}
template<> template<>
void X0<int>::g(int) { // expected-error{{after instantiation}}
}
template<>
struct X0<int>::Nested { }; // expected-error{{after instantiation}}
template<>
int X0<int>::member = 17; // expected-error{{after instantiation}}
template<>
struct X0<int> { }; // expected-error{{after instantiation}}
// Example from the standard
template<class T> class Array { /* ... */ };
template<class T> void sort(Array<T>& v) { /* ... */ }
struct String {};
void f(Array<String>& v) {
sort(v); // expected-note{{required}}
// use primary template
// sort(Array<T>&), T is String
}
template<> void sort<String>(Array<String>& v); // // expected-error{{after instantiation}}
template<> void sort<>(Array<char*>& v); // OK: sort<char*> not yet used
namespace PR6160 {
template<typename T> void f(T);
template<> void f(int);
extern template void f(int);
template<> void f(int) { }
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.spec/temp.expl.spec/p18.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class T1> class A {
template<class T2> class B {
template<class T3> void mf1(T3);
void mf2();
};
};
template<> template<class X>
class A<long>::B { };
template<> template<> template<class T>
void A<int>::B<double>::mf1(T t) { }
template<> template<> template<class T>
void A<long>::B<double>::mf1(T t) { } // expected-error{{does not match}}
// FIXME: This diagnostic could probably be better.
template<class Y> template<>
void A<Y>::B<double>::mf2() { } // expected-error{{does not refer}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1-11.cpp
|
// RUN: %clang_cc1 -std=c++11 %s -verify -triple x86_64-linux-gnu
namespace std {
typedef decltype(nullptr) nullptr_t;
}
template<int *ip> struct IP { // expected-note 5 {{template parameter is declared here}}
IP<ip> *ip2;
};
template<int &ip> struct IR {};
constexpr std::nullptr_t get_nullptr() { return nullptr; }
constexpr std::nullptr_t np = nullptr;
std::nullptr_t nonconst_np; // expected-note{{declared here}}
thread_local int tl; // expected-note {{refers here}}
IP<0> ip0; // expected-error{{null non-type template argument must be cast to template parameter type 'int *'}}
IP<(0)> ip1; // expected-error{{null non-type template argument must be cast to template parameter type 'int *'}}
IP<nullptr> ip2;
IP<get_nullptr()> ip3;
IP<(int*)0> ip4;
IP<np> ip5;
IP<nonconst_np> ip5; // expected-error{{non-type template argument of type 'std::nullptr_t' (aka 'nullptr_t') is not a constant expression}} \
// expected-note{{read of non-constexpr variable 'nonconst_np' is not allowed in a constant expression}}
IP<(float*)0> ip6; // expected-error{{null non-type template argument of type 'float *' does not match template parameter of type 'int *'}}
IP<&tl> ip7; // expected-error{{non-type template argument of type 'int *' is not a constant expression}}
IR<tl> ir1; // expected-error{{non-type template argument refers to thread-local object}}
struct X { };
template<int X::*pm> struct PM { // expected-note 2 {{template parameter is declared here}}
PM<pm> *pm2;
};
PM<0> pm0; // expected-error{{null non-type template argument must be cast to template parameter type 'int X::*'}}
PM<(0)> pm1; // expected-error{{null non-type template argument must be cast to template parameter type 'int X::*'}}
PM<nullptr> pm2;
PM<get_nullptr()> pm3;
PM<(int X::*)0> pm4;
PM<np> pm5;
template<int (X::*pmf)(int)> struct PMF { // expected-note 2 {{template parameter is declared here}}
PMF<pmf> *pmf2;
};
PMF<0> pmf0; // expected-error{{null non-type template argument must be cast to template parameter type 'int (X::*)(int)'}}
PMF<(0)> pmf1; // expected-error{{null non-type template argument must be cast to template parameter type 'int (X::*)(int)'}}
PMF<nullptr> pmf2;
PMF<get_nullptr()> pmf3;
PMF<(int (X::*)(int))0> pmf4;
PMF<np> pmf5;
template<std::nullptr_t np> struct NP { // expected-note 2{{template parameter is declared here}}
NP<np> *np2;
};
NP<nullptr> np1;
NP<np> np2;
NP<get_nullptr()> np3;
NP<0> np4; // expected-error{{null non-type template argument must be cast to template parameter type 'std::nullptr_t' (aka 'nullptr_t')}}
constexpr int i = 7;
NP<i> np5; // expected-error{{non-type template argument of type 'const int' cannot be converted to a value of type 'std::nullptr_t'}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -triple=x86_64-linux-gnu %s
// C++11 [temp.arg.nontype]p1:
//
// A template-argument for a non-type, non-template template-parameter shall
// be one of:
// -- an integral constant expression; or
// -- the name of a non-type template-parameter ; or
namespace non_type_tmpl_param {
template <int N> struct X0 { X0(); };
template <int N> X0<N>::X0() { }
template <int* N> struct X1 { X1(); };
template <int* N> X1<N>::X1() { }
template <int& N> struct X3 { X3(); };
template <int& N> X3<N>::X3() { }
template <int (*F)(int)> struct X4 { X4(); };
template <int (*F)(int)> X4<F>::X4() { }
template <typename T, int (T::* M)(int)> struct X5 { X5(); };
template <typename T, int (T::* M)(int)> X5<T, M>::X5() { }
}
// -- a constant expression that designates the address of an object with
// static storage duration and external or internal linkage or a function
// with external or internal linkage, including function templates and
// function template-ids, but excluting non-static class members, expressed
// (ignoring parentheses) as & id-expression, except that the & may be
// omitted if the name refers to a function or array and shall be omitted
// if the corresopnding template-parameter is a reference; or
namespace addr_of_obj_or_func {
template <int* p> struct X0 { }; // expected-note 5{{here}}
template <int (*fp)(int)> struct X1 { };
template <int &p> struct X2 { }; // expected-note 4{{here}}
template <const int &p> struct X2k { }; // expected-note {{here}}
template <int (&fp)(int)> struct X3 { }; // expected-note 4{{here}}
int i = 42;
int iarr[10];
int f(int i);
const int ki = 9; // expected-note 5{{here}}
__thread int ti = 100; // expected-note 2{{here}}
static int f_internal(int); // expected-note 4{{here}}
template <typename T> T f_tmpl(T t);
struct S { union { int NonStaticMember; }; };
void test() {
X0<i> x0a; // expected-error {{must have its address taken}}
X0<&i> x0a_addr;
X0<iarr> x0b;
X0<&iarr> x0b_addr; // expected-error {{cannot be converted to a value of type 'int *'}}
X0<ki> x0c; // expected-error {{must have its address taken}} expected-warning {{internal linkage is a C++11 extension}}
X0<&ki> x0c_addr; // expected-error {{cannot be converted to a value of type 'int *'}} expected-warning {{internal linkage is a C++11 extension}}
X0<&ti> x0d_addr; // expected-error {{refers to thread-local object}}
X1<f> x1a;
X1<&f> x1a_addr;
X1<f_tmpl> x1b;
X1<&f_tmpl> x1b_addr;
X1<f_tmpl<int> > x1c;
X1<&f_tmpl<int> > x1c_addr;
X1<f_internal> x1d; // expected-warning {{internal linkage is a C++11 extension}}
X1<&f_internal> x1d_addr; // expected-warning {{internal linkage is a C++11 extension}}
X2<i> x2a;
X2<&i> x2a_addr; // expected-error {{address taken}}
X2<iarr> x2b; // expected-error {{cannot bind to template argument of type 'int [10]'}}
X2<&iarr> x2b_addr; // expected-error {{address taken}}
X2<ki> x2c; // expected-error {{ignores qualifiers}} expected-warning {{internal linkage is a C++11 extension}}
X2k<ki> x2kc; // expected-warning {{internal linkage is a C++11 extension}}
X2k<&ki> x2kc_addr; // expected-error {{address taken}} expected-warning {{internal linkage is a C++11 extension}}
X2<ti> x2d_addr; // expected-error {{refers to thread-local object}}
X3<f> x3a;
X3<&f> x3a_addr; // expected-error {{address taken}}
X3<f_tmpl> x3b;
X3<&f_tmpl> x3b_addr; // expected-error {{address taken}}
X3<f_tmpl<int> > x3c;
X3<&f_tmpl<int> > x3c_addr; // expected-error {{address taken}}
X3<f_internal> x3d; // expected-warning {{internal linkage is a C++11 extension}}
X3<&f_internal> x3d_addr; // expected-error {{address taken}} expected-warning {{internal linkage is a C++11 extension}}
int n; // expected-note {{here}}
X0<&n> x0_no_linkage; // expected-error {{non-type template argument refers to object 'n' that does not have linkage}}
struct Local { static int f() {} }; // expected-note {{here}}
X1<&Local::f> x1_no_linkage; // expected-error {{non-type template argument refers to function 'f' that does not have linkage}}
X0<&S::NonStaticMember> x0_non_static; // expected-error {{non-static data member}}
}
}
// -- a constant expression that evaluates to a null pointer value (4.10); or
// -- a constant expression that evaluates to a null member pointer value
// (4.11); or
// -- a pointer to member expressed as described in 5.3.1.
namespace bad_args {
template <int* N> struct X0 { }; // expected-note 2{{template parameter is declared here}}
int i = 42;
X0<&i + 2> x0a; // expected-error{{non-type template argument does not refer to any declaration}}
int* iptr = &i;
X0<iptr> x0b; // expected-error{{non-type template argument for template parameter of pointer type 'int *' must have its address taken}}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg/temp.arg.nontype/p5.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// C++0x [temp.arg.nontype] p5:
// The following conversions are performed on each expression used as
// a non-type template-argument. If a non-type template-argument cannot be
// converted to the type of the corresponding template-parameter then the
// program is ill-formed.
// -- for a non-type template-parameter of integral or enumeration type,
// integral promotions (4.5) and integral conversions (4.7) are applied.
namespace integral_parameters {
template<short s> struct X0 { };
X0<17> x0i;
X0<'a'> x0c;
template<char c> struct X1 { };
X1<100l> x1l;
}
// -- for a non-type template-parameter of type pointer to object,
// qualification conversions (4.4) and the array-to-pointer conversion
// (4.2) are applied; if the template-argument is of type
// std::nullptr_t, the null pointer conversion (4.10) is applied.
namespace pointer_to_object_parameters {
// PR6226
struct Str {
Str(const char *);
};
template<const char *s>
struct A {
Str get() { return s; }
};
char hello[6] = "Hello";
extern const char world[6];
const char world[6] = "world";
void test() {
(void)A<hello>().get();
(void)A<world>().get();
}
class X {
public:
X();
X(int, int);
operator int() const;
};
template<X const *Ptr> struct A2; // expected-note{{template parameter is declared here}}
X *X_ptr;
X an_X;
X array_of_Xs[10];
A2<X_ptr> *a12; // expected-error{{must have its address taken}}
A2<array_of_Xs> *a13;
A2<&an_X> *a13_2;
A2<(&an_X)> *a13_3; // expected-warning{{address non-type template argument cannot be surrounded by parentheses}}
// PR6244
struct X1 {} X1v;
template <X1*> struct X2 { };
template <X1* Value> struct X3 : X2<Value> { };
struct X4 : X3<&X1v> { };
// PR6563
int *bar;
template <int *> struct zed {}; // expected-note 2{{template parameter is declared here}}
void g(zed<bar>*); // expected-error{{must have its address taken}}
int baz;
void g2(zed<baz>*); // expected-error{{must have its address taken}}
void g3(zed<&baz>*); // okay
}
// -- For a non-type template-parameter of type reference to object, no
// conversions apply. The type referred to by the reference may be more
// cv-qualified than the (otherwise identical) type of the
// template-argument. The template-parameter is bound directly to the
// template-argument, which shall be an lvalue.
namespace reference_parameters {
template <int& N> struct S0 { }; // expected-note 3 {{template parameter is declared here}}
template <const int& N> struct S1 { }; // expected-note 2 {{template parameter is declared here}}
template <volatile int& N> struct S2 { }; // expected-note 2 {{template parameter is declared here}}
template <const volatile int& N> struct S3 { };
int i;
extern const int ci;
volatile int vi;
extern const volatile int cvi;
void test() {
S0<i> s0;
S0<ci> s0c; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'const int' ignores qualifiers}}
S0<vi> s0v; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'volatile int' ignores qualifiers}}
S0<cvi> s0cv; // expected-error{{reference binding of non-type template parameter of type 'int &' to template argument of type 'const volatile int' ignores qualifiers}}
S1<i> s1;
S1<ci> s1c;
S1<vi> s1v; // expected-error{{reference binding of non-type template parameter of type 'const int &' to template argument of type 'volatile int' ignores qualifiers}}
S1<cvi> s1cv; // expected-error{{reference binding of non-type template parameter of type 'const int &' to template argument of type 'const volatile int' ignores qualifiers}}
S2<i> s2;
S2<ci> s2c; // expected-error{{reference binding of non-type template parameter of type 'volatile int &' to template argument of type 'const int' ignores qualifiers}}
S2<vi> s2v;
S2<cvi> s2cv; // expected-error{{reference binding of non-type template parameter of type 'volatile int &' to template argument of type 'const volatile int' ignores qualifiers}}
S3<i> s3;
S3<ci> s3c;
S3<vi> s3v;
S3<cvi> s3cv;
}
namespace PR6250 {
template <typename T, const T &ref> void inc() {
ref++; // expected-error{{read-only variable is not assignable}}
}
template<typename T, const T &ref> void bind() {
T &ref2 = ref; // expected-error{{drops 'const' qualifier}}
}
int counter;
void test() {
inc<int, counter>(); // expected-note{{instantiation of}}
bind<int, counter>(); // expected-note{{instantiation of}}
}
}
namespace PR6749 {
template <int& i> struct foo {}; // expected-note{{template parameter is declared here}}
int x, &y = x;
foo<y> f; // expected-error{{is not an object}}
}
}
// -- For a non-type template-parameter of type pointer to function, the
// function-to-pointer conversion (4.3) is applied; if the
// template-argument is of type std::nullptr_t, the null pointer
// conversion (4.10) is applied. If the template-argument represents
// a set of overloaded functions (or a pointer to such), the matching
// function is selected from the set (13.4).
namespace pointer_to_function {
template<int (*)(int)> struct X0 { }; // expected-note 3{{template parameter is declared here}}
int f(int);
int f(float);
int g(float);
int (*funcptr)(int);
void x0a(X0<f>);
void x0b(X0<&f>);
void x0c(X0<g>); // expected-error{{non-type template argument of type 'int (float)' cannot be converted to a value of type 'int (*)(int)'}}
void x0d(X0<&g>); // expected-error{{non-type template argument of type 'int (*)(float)' cannot be converted to a value of type 'int (*)(int)'}}
void x0e(X0<funcptr>); // expected-error{{must have its address taken}}
}
// -- For a non-type template-parameter of type reference to function, no
// conversions apply. If the template-argument represents a set of
// overloaded functions, the matching function is selected from the set
// (13.4).
namespace reference_to_function {
template<int (&)(int)> struct X0 { }; // expected-note 4{{template parameter is declared here}}
int f(int);
int f(float);
int g(float);
int (*funcptr)(int);
void x0a(X0<f>);
void x0b(X0<&f>); // expected-error{{address taken in non-type template argument for template parameter of reference type 'int (&)(int)'}}
void x0c(X0<g>); // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'int (float)'}}
void x0d(X0<&g>); // expected-error{{address taken in non-type template argument for template parameter of reference type 'int (&)(int)'}}
void x0e(X0<funcptr>); // expected-error{{non-type template parameter of reference type 'int (&)(int)' cannot bind to template argument of type 'int (*)(int)'}}
}
// -- For a non-type template-parameter of type pointer to member function,
// if the template-argument is of type std::nullptr_t, the null member
// pointer conversion (4.11) is applied; otherwise, no conversions
// apply. If the template-argument represents a set of overloaded member
// functions, the matching member function is selected from the set
// (13.4).
namespace pointer_to_member_function {
struct X { };
struct Y : X {
int f(int);
int g(int);
int g(float);
float h(float);
};
template<int (Y::*)(int)> struct X0 {}; // expected-note{{template parameter is declared here}}
X0<&Y::f> x0a;
X0<&Y::g> x0b;
X0<&Y::h> x0c; // expected-error-re{{non-type template argument of type 'float (pointer_to_member_function::Y::*)(float){{( __attribute__\(\(thiscall\)\))?}}' cannot be converted to a value of type 'int (pointer_to_member_function::Y::*)(int){{( __attribute__\(\(thiscall\)\))?}}'}}
}
// -- For a non-type template-parameter of type pointer to data member,
// qualification conversions (4.4) are applied; if the template-argument
// is of type std::nullptr_t, the null member pointer conversion (4.11)
// is applied.
namespace pointer_to_member_data {
struct X { int x; };
struct Y : X { int y; };
template<int Y::*> struct X0 {}; // expected-note{{template parameter is declared here}}
X0<&Y::y> x0a;
X0<&Y::x> x0b; // expected-error{{non-type template argument of type 'int pointer_to_member_data::X::*' cannot be converted to a value of type 'int pointer_to_member_data::Y::*'}}
// Test qualification conversions
template<const int Y::*> struct X1 {};
X1<&Y::y> x1a;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg/temp.arg.type/p2.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class T> struct A {
static T t; // expected-error{{static data member instantiated with function type 'int ()'}}
};
typedef int function();
A<function> a; // expected-note{{instantiation of}}
template<typename T> struct B {
B() { T t; } // expected-error{{variable instantiated with function type 'int ()'}}
};
B<function> b; // expected-note{{instantiation of}}
template <typename T> int f0(void *, const T&); // expected-note{{candidate template ignored: substitution failure}}
enum {e}; // expected-note{{unnamed type used in template argument was declared here}}
void test_f0(int n) {
int i = f0(0, e); // expected-warning{{template argument uses unnamed type}}
int vla[n];
f0(0, vla); // expected-error{{no matching function for call to 'f0'}}
}
namespace N0 {
template <typename R, typename A1> void f0(R (*)(A1));
template <typename T> int f1(T);
template <typename T, typename U> int f1(T, U);
enum {e1}; // expected-note 2{{unnamed type used in template argument was declared here}}
enum {e2}; // expected-note 2{{unnamed type used in template argument was declared here}}
enum {e3}; // expected-note{{unnamed type used in template argument was declared here}}
template<typename T> struct X;
template<typename T> struct X<T*> { };
void f() {
f0( // expected-warning{{template argument uses unnamed type}}
&f1<__typeof__(e1)>); // expected-warning{{template argument uses unnamed type}}
int (*fp1)(int, __typeof__(e2)) = f1; // expected-warning{{template argument uses unnamed type}}
f1(e2); // expected-warning{{template argument uses unnamed type}}
f1(e2);
X<__typeof__(e3)*> x; // expected-warning{{template argument uses unnamed type}}
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg/temp.arg.type/p2-cxx0x.cpp
|
// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
// expected-no-diagnostics
// C++03 imposed restrictions in this paragraph that were lifted with 0x, so we
// just test that the example given now parses cleanly.
template <class T> class X { };
template <class T> void f(T t) { }
struct { } unnamed_obj;
void f() {
struct A { };
enum { e1 };
typedef struct { } B;
B b;
X<A> x1;
X<A*> x2;
X<B> x3;
f(e1);
f(unnamed_obj);
f(b);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.arg/temp.arg.template/p3-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
template <class T> struct eval; // expected-note 3{{template is declared here}}
template <template <class, class...> class TT, class T1, class... Rest>
struct eval<TT<T1, Rest...>> { };
template <class T1> struct A;
template <class T1, class T2> struct B;
template <int N> struct C;
template <class T1, int N> struct D;
template <class T1, class T2, int N = 17> struct E;
eval<A<int>> eA;
eval<B<int, float>> eB;
eval<C<17>> eC; // expected-error{{implicit instantiation of undefined template 'eval<C<17> >'}}
eval<D<int, 17>> eD; // expected-error{{implicit instantiation of undefined template 'eval<D<int, 17> >'}}
eval<E<int, float>> eE; // expected-error{{implicit instantiation of undefined template 'eval<E<int, float, 17> >}}
template<template <int ...N> class TT> struct X0 { }; // expected-note{{previous non-type template parameter with type 'int' is here}}
template<int I, int J, int ...Rest> struct X0a;
template<int ...Rest> struct X0b;
template<int I, long J> struct X0c; // expected-note{{template non-type parameter has a different type 'long' in template argument}}
X0<X0a> inst_x0a;
X0<X0b> inst_x0b;
X0<X0c> inst_x0c; // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
template<typename T,
template <T ...N> class TT> // expected-note{{previous non-type template parameter with type 'short' is here}}
struct X1 { };
template<int I, int J, int ...Rest> struct X1a;
template<long I, long ...Rest> struct X1b;
template<short I, short J> struct X1c;
template<short I, long J> struct X1d; // expected-note{{template non-type parameter has a different type 'long' in template argument}}
X1<int, X1a> inst_x1a;
X1<long, X1b> inst_x1b;
X1<short, X1c> inst_x1c;
X1<short, X1d> inst_x1d; // expected-error{{template template argument has different template parameters than its corresponding template template paramete}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep/p3.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
struct A0 {
struct K { };
};
template <typename T> struct B0: A0 {
static void f() {
K k;
}
};
namespace E1 {
typedef double A;
template<class T> class B {
typedef int A;
};
template<class T>
struct X : B<T> {
A* blarg(double *dp) {
return dp;
}
};
}
namespace E2 {
struct A {
struct B;
int *a;
int Y;
};
int a;
template<class T> struct Y : T {
struct B { /* ... */ };
B b;
void f(int i) { a = i; }
Y* p;
};
Y<A> ya;
}
namespace PR14402 {
template<typename T>
struct A {
typedef int n;
int f();
struct B {};
struct C : B {
// OK, can't be sure whether we derive from A yet.
using A::n;
int g() { return f(); }
};
struct D {
using A::n; // expected-error {{using declaration refers into 'A<T>::', which is not a base class of 'D'}}
int g() { return f(); } // expected-error {{call to non-static member function 'f' of 'A' from nested type 'D'}}
};
struct E { char &f(); };
struct F : E {
// FIXME: Reject this prior to instantiation; f() is known to return int.
char &g() { return f(); }
// expected-error@-1 {{'PR14402::A<int>::f' is not a member of class 'PR14402::A<int>::F'}}
// expected-error@-2 {{non-const lvalue reference to type 'char' cannot bind to a temporary of type 'int'}}
};
};
template<> struct A<int>::B : A<int> {};
A<int>::C::n n = A<int>::C().g();
// 'not a member'
char &r = A<int>::F().g(); // expected-note {{in instantiation of}}
template<> struct A<char>::E : A<char> {};
// 'cannot bind to a temporary'
char &s = A<char>::F().g(); // expected-note {{in instantiation of}}
struct X;
struct X { void f(); };
struct X;
template<typename T> struct Y : X {
void g() {
X::f();
}
};
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -verify %s
// expected-no-diagnostics
template<int n> struct S;
template<int n> struct T {
T() {
// An identifier is value-dependent if it is:
// - a name declared with a dependent type
S<n> s;
S<s> check1; // ok, s is value-dependent
// - the name of a non-type template parameter
typename S<n>::T check2; // ok, n is value-dependent
// - a constant with literal type and is initialized with an expression
// that is value-dependent.
const int k = n;
typename S<k>::T check3a; // ok, u is value-dependent
constexpr const int *p = &k;
typename S<*p>::T check3b; // ok, p is value-dependent
// (missing from the standard)
// - a reference and is initialized with an expression that is
// value-dependent.
const int &i = k;
typename S<i>::T check4; // ok, i is value-dependent
}
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.constexpr/p2.cpp
|
// RUN: %clang_cc1 -std=c++98 -verify %s
template<int n> struct S;
template<int n> struct T {
T() {
// An identifier is value-dependent if it is:
// - a name declared with a dependent type
S<n> s;
S<s> check1; // ok, s is value-dependent
// - the name of a non-type template parameter
typename S<n>::T check2; // ok, n is value-dependent
// - a constant with literal type and is initialized with an expression
// that is value-dependent.
const int k = n;
typename S<k>::T check3; // ok, u is value-dependent
const int &i = k;
typename S<i>::T check4; // expected-error {{not an integral constant expression}} expected-error {{qualified name}}
}
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep/temp.dep.type/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
// Examples from CWG1056.
namespace Example1 {
template<class T> struct A;
template<class T> using B = A<T>;
template<class T> struct A {
struct C {};
B<T>::C bc; // ok, B<T> is the current instantiation.
};
template<class T> struct A<A<T>> {
struct C {};
B<B<T>>::C bc; // ok, B<B<T>> is the current instantiation.
};
template<class T> struct A<A<A<T>>> {
struct C {};
B<B<T>>::C bc; // expected-error {{missing 'typename'}}
};
}
namespace Example2 {
template<class T> struct A {
void g();
};
template<class T> using B = A<T>;
template<class T> void B<T>::g() {} // ok.
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.local/p7.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
template<class T> struct A {
int B;
int f();
};
template<class B> int A<B>::f() {
return B;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.local/p9.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
struct A {
struct B { void f(); };
int a;
int Y;
};
template<class B, class a> struct X : A {
B b; // A's B
a c; // expected-error{{unknown type name 'a'}}
void g() {
b.g(); // expected-error{{no member named 'g' in 'A::B'}}
}
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.local/p8.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
namespace N {
enum { C };
template<class T> class B {
void f(T);
};
}
template<class C> void N::B<C>::f(C) {
C b;
}
namespace N {
enum { D };
namespace M {
enum { C , D };
template<typename C> class X {
template<typename U> void f(C, U);
template<typename D> void g(C, D) {
C c;
D d;
}
};
struct Y {
template<typename U> void f(U);
};
}
struct Y {
template<typename D> void f(D);
};
}
template<typename C>
template<typename D>
void N::M::X<C>::f(C, D) {
C c;
D d;
}
template<typename C>
void N::M::Y::f(C) {
C c;
}
template<typename D>
void N::Y::f(D) {
D d;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.local/p3.cpp
|
// RUN: %clang_cc1 -verify %s
template <class T> struct Base { // expected-note 4 {{member found by ambiguous name lookup}}
static void f();
};
struct X0 { };
template <class T> struct Derived: Base<int>, Base<char> {
typename Derived::Base b; // expected-error{{member 'Base' found in multiple base classes of different types}}
typename Derived::Base<double> d; // OK
void g(X0 *t) {
t->Derived::Base<T>::f();
t->Base<T>::f();
t->Base::f(); // expected-error{{member 'Base' found in multiple base classes of different types}} \
// expected-error{{no member named 'f' in 'X0'}} \
// expected-error{{'Base' is not a class, namespace, or enumeration}}
}
};
namespace PR6717 {
template <typename T>
class WebVector {
} // expected-error {{expected ';' after class}}
WebVector(const WebVector<T>& other) { } // expected-error{{undeclared identifier 'T'}} \
expected-error{{requires a type specifier}}
template <typename C>
WebVector<T>& operator=(const C& other) { } // expected-error{{undeclared identifier 'T'}}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.local/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
// C++0x [temp.local]p1:
// Like normal (non-template) classes, class templates have an
// injected-class-name (Clause 9). The injected-class-name can be used with
// or without a template-argument-list. When it is used without
// a template-argument-list, it is equivalent to the injected-class-name
// followed by the template-parameters of the class template enclosed in <>.
template <typename T> struct X0 {
X0();
~X0();
X0 f(const X0&);
};
// Test non-type template parameters.
template <int N1, const int& N2, const int* N3> struct X1 {
X1();
~X1();
X1 f(const X1& x1a) { X1 x1b(x1a); return x1b; }
};
// When it is used with a template-argument-list, it refers to the specified
// class template specialization, which could be the current specialization
// or another specialization.
// FIXME: Test this clause.
int i = 42;
void test() {
X0<int> x0; (void)x0;
X1<42, i, &i> x1; (void)x1;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.local/p6.cpp
|
// RUN: %clang_cc1 -verify %s -fcxx-exceptions -std=c++1y
template<typename T, // expected-note {{declared here}}
typename T> struct X {}; // expected-error {{declaration of 'T' shadows template parameter}}
template<typename T> struct Y { // expected-note 15{{declared here}}
template<typename T> struct A {}; // expected-error {{declaration of 'T' shadows template parameter}}
struct B {
template<typename> struct T {}; // FIXME: desired-error {{declaration of 'T' shadows template parameter}}
};
struct C {
template<typename> void T(); // expected-error {{declaration of 'T' shadows template parameter}}
};
struct D {
struct T {}; // expected-error {{declaration of 'T' shadows template parameter}}
};
struct E {
typedef int T; // expected-error {{declaration of 'T' shadows template parameter}}
};
struct F {
using T = int; // expected-error {{declaration of 'T' shadows template parameter}}
};
struct G {
int T; // expected-error {{declaration of 'T' shadows template parameter}}
};
struct H {
static int T; // expected-error {{declaration of 'T' shadows template parameter}}
};
struct I {
void T(); // expected-error {{declaration of 'T' shadows template parameter}}
};
struct J {
enum T { e }; // expected-error {{declaration of 'T' shadows template parameter}}
};
struct K {
enum E { T }; // expected-error {{declaration of 'T' shadows template parameter}}
};
void a() {
extern int T; // expected-error {{declaration of 'T' shadows template parameter}}
}
void b() {
int T; // expected-error {{declaration of 'T' shadows template parameter}}
}
void c() {
try {}
catch (int T) {} // expected-error {{declaration of 'T' shadows template parameter}}
}
void d() {
void T(); // expected-error {{declaration of 'T' shadows template parameter}}
}
friend struct T; // expected-error {{declaration of 'T' shadows template parameter}}
};
template<typename T> // expected-note {{declared here}}
void f(int T) {} // expected-error {{declaration of 'T' shadows template parameter}}
// FIXME: These are ill-formed: a template-parameter shall not have the same name as the template name.
namespace A {
template<typename T> struct T {};
}
namespace B {
template<typename T> void T() {}
}
namespace C {
template<typename T> int T;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep.res
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.res/temp.dep.res/temp.point/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// XFAIL: *
// Note: we fail this test because we perform template instantiation
// at the end of the translation unit, so argument-dependent lookup
// finds functions that occur after the point of instantiation. Note
// that GCC fails this test; EDG passes the test in strict mode, but
// not in relaxed mode.
namespace N {
struct A { };
struct B : public A { };
int& f0(A&);
}
template<typename T, typename Result>
struct X0 {
void test_f0(T t) {
Result r = f0(t);
};
};
void test_f0() {
X0<N::A, int&> xA;
xA.test_f0(N::A());
X0<N::B, int&> xB;
xB.test_f0(N::B());
}
namespace N {
char& f0(B&);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p15-cxx0x.cpp
|
// RUN: %clang_cc1 -fsyntax-only -std=c++11 -verify %s
template<typename T> struct X; // expected-note {{'X' is incomplete}}
template<int I> struct Y;
X<X<int>> *x1;
Y<(1 >> 2)> *y1;
Y<1 >> 2> *y2; // FIXME: expected-error{{expected unqualified-id}}
X<X<X<X<X<int>>>>> *x2;
template<> struct X<int> { };
typedef X<int> X_int;
struct Z : X_int { };
void f(const X<int> x) {
(void)reinterpret_cast<X<int>>(x); // expected-error{{reinterpret_cast from}}
(void)reinterpret_cast<X<X<X<int>>>>(x); // expected-error{{reinterpret_cast from}}
X<X<int>> *x1;
}
template<typename T = void> struct X1 { };
X1<X1<>> x1a;
namespace ParameterPackExpansions {
// A template parameter pack that [contains an unexpanded parameter pack] is a
// pack expansion.
template<typename...Ts> struct Outer {
// From [temp.variadic]p4:
// In a template parameter pack that is a pack expansion, the pattern is
// [...the template-parameter...] without the ellipsis.
// Therefore the resulting sequence of parameters is not a parameter pack,
// so is not required to be the last template parameter.
template<Ts ...As, template<Ts> class ...Bs, typename ...Cs> struct Inner {
struct Check : Bs<As>... {
Check(Cs...);
};
};
};
template<int> struct TemplateInt {};
template<char> struct TemplateChar {};
template<int*> struct TemplateIntPtr {};
int x;
Outer<int, char, int*>::
Inner<12345, 'x', &x,
TemplateInt, TemplateChar, TemplateIntPtr,
int*>::
Check check(&x);
template<typename...Ts> struct types;
enum place { _ };
template<place...> struct places {};
template<typename P1, typename P2> struct append_places;
template<place...X1, place...X2>
struct append_places<places<X1...>, places<X2...>> {
typedef places<X1...,X2...> type;
};
template<unsigned N>
struct make_places : append_places<typename make_places<N/2>::type,
typename make_places<N-N/2>::type> {};
template<> struct make_places<0> { typedef places<> type; };
template<> struct make_places<1> { typedef places<_> type; };
template<typename T> struct wrap {
template<place> struct inner { typedef T type; };
};
template<typename T> struct takedrop_impl;
template<place...X> struct takedrop_impl<places<X...>> {
template<template<decltype(X)> class ...Take,
template<place > class ...Drop>
struct inner { // expected-note 2{{declared}}
typedef types<typename Take<_>::type...> take;
typedef types<typename Drop<_>::type...> drop;
};
};
template<unsigned N, typename...Ts> struct take {
using type = typename takedrop_impl<typename make_places<N>::type>::
template inner<wrap<Ts>::template inner...>::take; // expected-error {{too few template arguments}}
};
template<unsigned N, typename...Ts> struct drop {
using type = typename takedrop_impl<typename make_places<N>::type>::
template inner<wrap<Ts>::template inner...>::drop; // expected-error {{too few template arguments}}
};
using T1 = take<3, int, char, double, long>::type; // expected-note {{previous}}
// FIXME: Desguar the types on the RHS in this diagnostic.
// desired-error {{'types<void, void, void, void>' vs 'types<int, char, double, (no argument)>'}}
using T1 = types<void, void, void, void>; // expected-error {{'types<void, void, void, void>' vs 'types<typename inner<_>::type, typename inner<_>::type, typename inner<_>::type, (no argument)>'}}
using D1 = drop<3, int, char, double, long>::type;
using D1 = types<long>;
using T2 = take<4, int, char, double, long>::type; // expected-note {{previous}}
using T2 = types<int, char, double, long>;
// FIXME: Desguar the types on the RHS in this diagnostic.
// desired-error {{'types<void, void, void, void>' vs 'types<int, char, double, long>'}}
using T2 = types<void, void, void, void>; // expected-error {{'types<void, void, void, void>' vs 'types<typename inner<_>::type, typename inner<_>::type, typename inner<_>::type, typename inner<_>::type>'}}
using D2 = drop<4, int, char, double, long>::type;
using D2 = types<>;
using T3 = take<5, int, char, double, long>::type; // expected-note {{in instantiation of}}
using D3 = drop<5, int, char, double, long>::type; // expected-note {{in instantiation of}}
// FIXME: We should accept this code. A parameter pack within a default argument
// in a template template parameter pack is expanded, because the pack is
// implicitly a pack expansion.
template<typename ...Default> struct DefArg {
template<template<typename T = Default> class ...Classes> struct Inner { // expected-error {{default argument contains unexpanded parameter pack}} expected-note {{here}}
Inner(Classes<>...); // expected-error {{too few}}
};
};
template<typename T> struct vector {};
template<typename T> struct list {};
vector<int> vi;
list<char> lc;
DefArg<int, char>::Inner<vector, list> defarg(vi, lc);
// FIXME:
// A template parameter pack that is a pack expansion shall not expand a
// parameter pack declared in the same template-parameter-list.
template<typename...Ts, Ts...Vs> void error(); // desired-error
// This case should not produce an error, because in A's instantiation, Cs is
// not a parameter pack.
template<typename...Ts> void consume(Ts...);
template<typename...Ts> struct A {
template<template<typename, Ts = 0> class ...Cs, Cs<Ts> ...Vs> struct B { // ok
B() {
consume([]{
int arr[Vs]; // expected-error {{negative size}}
}...);
}
};
};
template<typename, int> using Int = int;
template<typename, short> using Char = char;
A<int, short>::B<Int, Char, -1, 'x'> b; // expected-note {{here}}
}
namespace PR9023 {
template<typename ...T> struct A {
template<template<T> class ...> struct B {
};
};
template<int> struct C { };
template<long> struct D { };
int main() {
A<int, long>::B<C, D> e;
}
}
namespace std_examples {
template <class... Types> class Tuple;
template <class T, int... Dims> struct multi_array;
template <class... T> struct value_holder {
template<T... Values> struct apply { };
};
template <class... T, T... Values> struct static_array; // expected-error {{must be the last}}
int n;
value_holder<int, char, int*>::apply<12345, 'x', &n> test;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p7.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// A non-type template-parameter shall not be declared to have
// floating point, class, or void type.
struct A;
template<double d> class X; // expected-error{{cannot have type}}
template<double* pd> class Y; //OK
template<double& rd> class Z; //OK
template<A a> class X0; // expected-error{{cannot have type}}
typedef void VOID;
template<VOID a> class X01; // expected-error{{cannot have type}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p9.cpp
|
// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s
// A default template-argument shall not be specified in a function
// template declaration or a function template definition
template<typename T = int> // expected-warning{{default template arguments for a function template are a C++11 extension}}
void foo0(T);
template<typename T = int> // expected-warning{{default template arguments for a function template are a C++11 extension}}
void foo1(T) { }
// [...] nor in the template-parameter-list of the definition of a
// member of a class template.
template<int N>
struct X0 {
void f();
};
template<int N = 0> // expected-error{{cannot add a default template argument}}
void X0<N>::f() { }
class X1 {
template<template<int> class TT = X0> // expected-error{{not permitted on a friend template}}
friend void f2();
};
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p8.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
template<int X[10]> struct A;
template<int *X> struct A;
template<int f(float, double)> struct B;
typedef float FLOAT;
template<int (*f)(FLOAT, double)> struct B;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p9-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// A default template-argument may be specified for any kind of
// template-parameter that is not a template parameter pack.
template<typename ...Types = int> // expected-error{{template parameter pack cannot have a default argument}}
struct X0;
template<int ...Values = 0> // expected-error{{template parameter pack cannot have a default argument}}
struct X1;
template<typename T> struct vector;
template<template<class> class ...Templates = vector> // expected-error{{template parameter pack cannot have a default argument}}
struct X2;
struct X3 {
template<typename T = int> // expected-error{{default template argument not permitted on a friend template}}
friend void f0(X3);
template<typename T = int>
friend void f1(X3) {
}
};
namespace PR8748 {
// Testcase 1
struct A0 { template<typename U> struct B; };
template<typename U = int> struct A0::B { };
// Testcase 2
template<typename T> struct A1 { template<typename U> struct B; };
template<typename T> template<typename U = int> struct A1<T>::B { }; // expected-error{{cannot add a default template argument to the definition of a member of a class template}}
// Testcase 3
template<typename T>
struct X2 {
void f0();
template<typename U> void f1();
};
template<typename T = int> void X2<T>::f0() { } // expected-error{{cannot add a default template argument to the definition of a member of a class template}}
template<typename T> template<typename U = int> void X2<T>::f1() { } // expected-error{{cannot add a default template argument to the definition of a member of a class template}}
namespace Inner {
template<typename T> struct X3;
template<typename T> void f2();
}
// Okay; not class members.
template<typename T = int> struct Inner::X3 { };
template<typename T = int> void Inner::f2() {}
}
namespace PR10069 {
template<typename T, T a, T b=0, T c=1>
T f(T x);
void g() {
f<unsigned int, 0>(0);
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p10.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
template<typename> struct Y1;
template<typename, int> struct Y2;
template<class T1, class T2 = int> class B2;
template<class T1 = int, class T2> class B2;
template<template<class, int> class, template<class> class = Y1> class B2t;
template<template<class, int> class = Y2, template<class> class> class B2t;
template<int N, int M = 5> class B2n;
template<int N = 5, int M> class B2n;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p4.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
class X;
// C++ [temp.param]p4
typedef int INT;
enum E { enum1, enum2 };
template<int N> struct A1;
template<INT N, INT M> struct A2;
template<enum E x, E y> struct A3;
template<int &X> struct A4;
template<int *Ptr> struct A5;
template<int (&f)(int, int)> struct A6;
template<int (*fp)(float, double)> struct A7;
template<int X::*pm> struct A8;
template<float (X::*pmf)(float, int)> struct A9;
template<typename T, T x> struct A10;
template<float f> struct A11; // expected-error{{a non-type template parameter cannot have type 'float'}}
template<void *Ptr> struct A12;
template<int (*IncompleteArrayPtr)[]> struct A13;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p13.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
// The scope of atemplate-parameterextends from its point of
// declaration until the end of its template. In particular, a
// template-parameter can be used in the declaration of subsequent
// template-parameters and their default arguments.
template<class T, T* p, class U = T> class X { /* ... */ };
// FIXME: template<class T> void f(T* p = new T);
// Check for bogus template parameter shadow warning.
template<template<class T> class,
template<class T> class>
class B1noshadow;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p11-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// If a template-parameter of a class template or alias template has a default
// template-argument, each subsequent template-parameter shall either have a
// default template-argument supplied or be a template parameter pack.
template<typename> struct vector;
template<typename T = int, typename> struct X3t; // expected-error{{template parameter missing a default argument}} expected-note{{previous default template argument defined here}}
template<typename T = int, typename> using A3t = int; // expected-error{{template parameter missing a default argument}} expected-note{{previous default template argument defined here}}
template<int V = 0, int> struct X3nt; // expected-error{{template parameter missing a default argument}} expected-note{{previous default template argument defined here}}
template<int V = 0, int> using A3nt = int; // expected-error{{template parameter missing a default argument}} expected-note{{previous default template argument defined here}}
template<template<class> class M = vector, template<class> class> struct X3tt; // expected-error{{template parameter missing a default argument}} expected-note{{previous default template argument defined here}}
template<template<class> class M = vector, template<class> class> using A3tt = int; // expected-error{{template parameter missing a default argument}} expected-note{{previous default template argument defined here}}
template<typename T = int, typename ...Types> struct X2t;
template<typename T = int, typename ...Types> using A2t = X2t<T, Types...>;
template<int V = 0, int ...Values> struct X2nt;
template<int V = 0, int ...Values> using A2nt = X2nt<V, Values...>;
template<template<class> class M = vector, template<class> class... Metas>
struct X2tt;
template<template<class> class M = vector, template<class> class... Metas>
using A2tt = X2tt<M, Metas...>;
// If a template-parameter of a primary class template or alias template is a
// template parameter pack, it shall be the last template-parameter.
template<typename ...Types, // expected-error{{template parameter pack must be the last template parameter}}
int After, int After2>
struct X0t;
X0t<int> pr9789();
template<typename ...Types, // expected-error{{template parameter pack must be the last template parameter}}
int After>
using A0t = int;
template<int ...Values, // expected-error{{template parameter pack must be the last template parameter}}
int After>
struct X0nt;
template<int ...Values, // expected-error{{template parameter pack must be the last template parameter}}
int After>
using A0nt = int;
template<template<typename> class ...Templates, // expected-error{{template parameter pack must be the last template parameter}}
int After>
struct X0tt;
template<template<typename> class ...Templates, // expected-error{{template parameter pack must be the last template parameter}}
int After>
using A0tt = int;
// [ Note: These are not requirements for function templates or class
// template partial specializations because template arguments can be
// deduced (14.8.2). -- end note]
template<typename... Types> struct X1t;
template<typename ...Types, typename T> struct X1t<T, Types...> { };
template<int... Values> struct X1nt;
template<int ...Values, int V> struct X1nt<V, Values...> { };
template<template<int> class... Meta> struct X1tt;
template<template<int> class... Meta, template<int> class M>
struct X1tt<M, Meta...> { };
template<typename ...Types, typename T>
void f1t(X1t<T, Types...>);
template<int ...Values, int V>
void f1nt(X1nt<V, Values...>);
template<template<int> class... Meta, template<int> class M>
void f1tt(X1tt<M, Meta...>);
namespace DefaultTemplateArgsInFunction {
template<typename T = int, typename U> T &f0(U) { T *x = 0; return *x; }
void test_f0() {
int &ir0 = f0(3.14159);
int &ir1 = f0<int>(3.14159);
float &fr0 = f0<float>(3.14159);
}
template<> int &f0(int*);
template int &f0(double&);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p15.cpp
|
// RUN: %clang_cc1 -fsyntax-only -std=c++98 -verify %s
template<typename T> struct X;
template<int I> struct Y;
X<X<int> > *x1;
X<X<int>> *x2; // expected-error{{a space is required between consecutive right angle brackets (use '> >')}}
X<X<X<X<int>> // expected-error{{a space is required between consecutive right angle brackets (use '> >')}}
>> *x3; // expected-error{{a space is required between consecutive right angle brackets (use '> >')}}
Y<(1 >> 2)> *y1;
Y<1 >> 2> *y2; // expected-warning{{use of right-shift operator ('>>') in template argument will require parentheses in C++11}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p3.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// A type-parameter defines its identifier to be a type-name (if
// declared with class or typename) or template-name (if declared with
// template) in the scope of the template declaration.
template<typename T> struct X0 {
T* value;
};
template<template<class T> class Y> struct X1 {
Y<int> value;
};
// [Note: because of the name lookup rules, a template-parameter that
// could be interpreted as either a non-type template-parameter or a
// type-parameter (because its identifier is the name of an already
// existing class) is taken as a type-parameter. For example,
class T { /* ... */ }; // expected-note{{candidate constructor (the implicit copy constructor) not viable}}
int i;
template<class T, T i> struct X2 {
void f(T t)
{
T t1 = i; //template-parameters T and i
::T t2 = ::i; // global namespace members T and i \
// expected-error{{no viable conversion}}
}
};
namespace PR6831 {
namespace NA { struct S; }
namespace NB { struct S; }
using namespace NA;
using namespace NB;
template <typename S> void foo();
template <int S> void bar();
template <template<typename> class S> void baz();
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p2.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
// There is no semantic difference between class and typename in a
// template-parameter. typename followed by an unqualified-id names a
// template type parameter.
template<class T> struct X;
template<typename T> struct X;
// typename followed by aqualified-id denotes the type in a non-type
// parameter-declaration.
template<typename T, typename T::type Value> struct Y0;
template<typename T, typename X<T>::type Value> struct Y1;
// A storage class shall not be specified in a template-parameter declaration.
template<static int Value> struct Z; // FIXME: expect an error
// Make sure that we properly disambiguate non-type template parameters that
// start with 'class'.
class X1 { };
template<class X1 *xptr> struct Y2 { };
// FIXME: add the example from p2
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p1.cpp
|
// Suppress 'no run line' failure.
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<template<> class C> class D; // expected-error{{template template parameter must have its own template parameters}}
struct A {};
template<class M,
class T = A, // expected-note{{previous default template argument defined here}}
class C> // expected-error{{template parameter missing a default argument}}
class X0 {}; // expected-note{{template is declared here}}
X0<int> x0; // expected-error{{too few template arguments for class template 'X0'}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p12.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename> struct Y1; // expected-note{{too few template parameters in template template argument}}
template<typename, int> struct Y2;
// C++ [temp.param]p12:
template<class T1,
class T2 = int> // expected-note{{previous default template argument defined here}}
class B3;
template<class T1, typename T2> class B3;
template<class T1,
typename T2 = float> // expected-error{{template parameter redefines default argument}}
class B3;
template<template<class, int> class,
template<class> class = Y1> // expected-note{{previous default template argument defined here}}
class B3t;
template<template<class, int> class, template<class> class> class B3t;
template<template<class, int> class,
template<class> class = Y1> // expected-error{{template parameter redefines default argument}}
class B3t;
template<int N,
int M = 5> // expected-note{{previous default template argument defined here}}
class B3n;
template<int N, int M> class B3n;
template<int N,
int M = 7> // expected-error{{template parameter redefines default argument}}
class B3n;
// Check validity of default arguments
template<template<class, int> class // expected-note{{previous template template parameter is here}}
= Y1> // expected-error{{template template argument has different template parameters than its corresponding template template parameter}}
class C1 {};
C1<> c1; // expected-note{{while checking a default template argument}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p10-0x.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
// expected-no-diagnostics
template<typename> struct Y1;
template<typename, int> struct Y2;
template<class T1, class T2 = int> using B2 = T1;
template<class T1 = int, class T2> using B2 = T1;
template<template<class> class F, template<class> class G = Y1> using B2t = F<G<int>>;
template<template<class> class F = Y2, template<class> class G> using B2t = F<G<int>>;
template<int N, int M = 5> using B2n = Y2<int, N + M>;
template<int N = 5, int M> using B2n = Y2<int, N + M>;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p5.cpp
|
// RUN: %clang_cc1 -verify %s -std=c++11
template<const int I> struct S { // expected-note {{instantiation}}
decltype(I) n;
int &&r = I; // expected-warning 2{{binding reference member 'r' to a temporary value}} expected-note 2{{declared here}}
};
S<5> s;
template<typename T, T v> struct U { // expected-note {{instantiation}}
decltype(v) n;
int &&r = v; // expected-warning {{binding reference member 'r' to a temporary value}} expected-note {{declared here}}
};
U<const int, 6> u;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.param/p11.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename> struct Y1;
template<typename, int> struct Y2;
template<class T1 = int, // expected-note{{previous default template argument defined here}}
class T2> // expected-error{{template parameter missing a default argument}}
class B1;
template<template<class> class = Y1, // expected-note{{previous default template argument defined here}}
template<class> class> // expected-error{{template parameter missing a default argument}}
class B1t;
template<int N = 5, // expected-note{{previous default template argument defined here}}
int M> // expected-error{{template parameter missing a default argument}}
class B1n;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p9-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
// Metafunction to extract the Nth type from a set of types.
template<unsigned N, typename ...Types> struct get_nth_type;
template<unsigned N, typename Head, typename ...Tail>
struct get_nth_type<N, Head, Tail...> : get_nth_type<N-1, Tail...> { };
template<typename Head, typename ...Tail>
struct get_nth_type<0, Head, Tail...> {
typedef Head type;
};
// Placeholder type when get_nth_type fails.
struct no_type {};
template<unsigned N>
struct get_nth_type<N> {
typedef no_type type;
};
template<typename ...Args>
typename get_nth_type<0, Args...>::type first_arg(Args...);
template<typename ...Args>
typename get_nth_type<1, Args...>::type second_arg(Args...);
// Test explicit specification of function template arguments.
void test_explicit_spec_simple() {
int *ip1 = first_arg<int *>(0);
int *ip2 = first_arg<int *, float*>(0, 0);
float *fp1 = first_arg<float *, double*, int*>(0, 0, 0);
}
// Template argument deduction can extend the sequence of template
// arguments corresponding to a template parameter pack, even when the
// sequence contains explicitly specified template arguments.
void test_explicit_spec_extension(double *dp) {
int *ip1 = first_arg<int *>(0, 0);
int *ip2 = first_arg<int *, float*>(0, 0, 0, 0);
float *fp1 = first_arg<float *, double*, int*>(0, 0, 0);
int *i1 = second_arg<float *>(0, (int*)0, 0);
double *dp1 = first_arg<>(dp);
}
template<typename ...Types>
struct tuple { };
template<typename ...Types>
void accept_tuple(tuple<Types...>);
void test_explicit_spec_extension_targs(tuple<int, float, double> t3) {
accept_tuple(t3);
accept_tuple<int, float, double>(t3);
accept_tuple<int>(t3);
accept_tuple<int, float>(t3);
}
template<typename R, typename ...ParmTypes>
void accept_function_ptr(R(*)(ParmTypes...));
void test_explicit_spec_extension_funcparms(int (*f3)(int, float, double)) {
accept_function_ptr(f3);
accept_function_ptr<int>(f3);
accept_function_ptr<int, int>(f3);
accept_function_ptr<int, int, float>(f3);
accept_function_ptr<int, int, float, double>(f3);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3-nodeduct.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// PR5811
template <class F> void Call(F f) { f(1); }
template <typename T> void f(T);
void a() { Call(f<int>); }
// Check the conversion of a template-id to a pointer
template<typename T, T* Address> struct Constant { };
Constant<void(int), &f<int> > constant0;
template<typename T, T* Address> void constant_func();
void test_constant_func() {
constant_func<void(int), &f<int> >();
}
// Check typeof() on a template-id referring to a single function
template<typename T, typename U>
struct is_same {
static const bool value = false;
};
template<typename T>
struct is_same<T, T> {
static const bool value = true;
};
int typeof0[is_same<__typeof__(f<int>), void (int)>::value? 1 : -1];
int typeof1[is_same<__typeof__(&f<int>), void (*)(int)>::value? 1 : -1];
template <typename T> void g(T); // expected-note{{possible target for call}}
template <typename T> void g(T, T); // expected-note{{possible target for call}}
int typeof2[is_same<__typeof__(g<float>), void (int)>::value? 1 : -1]; // \
// expected-error{{reference to overloaded function could not be resolved; did you mean to call it?}}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<class X, class Y, class Z> X f(Y,Z); // expected-note {{candidate template ignored: couldn't infer template argument 'X'}}
void g() {
f<int,char*,double>("aa",3.0); // expected-warning{{conversion from string literal to 'char *' is deprecated}}
f<int,char*>("aa",3.0); // Z is deduced to be double \
// expected-warning{{conversion from string literal to 'char *' is deprecated}}
f<int>("aa",3.0); // Y is deduced to be char*, and
// Z is deduced to be double
f("aa",3.0); // expected-error{{no matching}}
}
// PR5910
namespace PR5910 {
template <typename T>
void Func() {}
template <typename R>
void Foo(R (*fp)());
void Test() {
Foo(Func<int>);
}
}
// PR5949
namespace PR5949 {
struct Bar;
template <class Container>
void quuz(const Container &cont) {
}
template<typename T>
int Foo(Bar *b, void (*Baz)(const T &t), T * = 0) {
return 0;
}
template<typename T>
int Quux(Bar *b, T * = 0)
{
return Foo<T>(b, quuz);
}
}
// PR7641
namespace PR7641 {
namespace N2
{
template<class>
int f0(int);
}
namespace N
{
using N2::f0;
}
template<class R,class B1>
int
f1(R(a)(B1));
void f2()
{ f1(N::f0<int>); }
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p3-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
namespace ParameterPacksWithFunctions {
template<typename ...> struct count;
template<typename Head, typename ...Tail>
struct count<Head, Tail...> {
static const unsigned value = 1 + count<Tail...>::value;
};
template<>
struct count<> {
static const unsigned value = 0;
};
template<unsigned> struct unsigned_c { };
template<typename ... Types>
unsigned_c<count<Types...>::value> f();
void test_f() {
unsigned_c<0> uc0a = f(); // okay, deduced to an empty pack
unsigned_c<0> uc0b = f<>();
unsigned_c<1> uc1 = f<int>();
unsigned_c<2> uc2 = f<float, double>();
}
}
namespace rdar12176336 {
typedef void (*vararg_func)(...);
struct method {
vararg_func implementation;
method(vararg_func implementation) : implementation(implementation) {}
template<typename TReturnType, typename... TArguments, typename TFunctionType = TReturnType (*)(TArguments...)>
auto getImplementation() const -> TFunctionType
{
return reinterpret_cast<TFunctionType>(implementation);
}
};
void f() {
method m(nullptr);
auto imp = m.getImplementation<int, int, int>();
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.arg.explicit/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only %s
template<typename T> struct A { };
template<typename T> T make();
template<typename T> T make2(const T&);
void test_make() {
int& ir0 = make<int&>();
A<int> a0 = make< A<int> >();
A<int> a1 = make2< A<int> >(A<int>());
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/cwg1170.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
// expected-no-diagnostics
#if !__has_feature(cxx_access_control_sfinae)
# error No support for access control as part of SFINAE?
#endif
typedef char yes_type;
typedef char (&no_type)[2];
template<unsigned N> struct unsigned_c { };
template<typename T>
class has_copy_constructor {
static T t;
template<typename U> static yes_type check(unsigned_c<sizeof(U(t))> * = 0);
template<typename U> static no_type check(...);
public:
static const bool value = (sizeof(check<T>(0)) == sizeof(yes_type));
};
struct HasCopy { };
struct HasNonConstCopy {
HasNonConstCopy(HasNonConstCopy&);
};
struct HasDeletedCopy {
HasDeletedCopy(const HasDeletedCopy&) = delete;
};
struct HasPrivateCopy {
private:
HasPrivateCopy(const HasPrivateCopy&);
};
int check0[has_copy_constructor<HasCopy>::value? 1 : -1];
int check1[has_copy_constructor<HasNonConstCopy>::value? 1 : -1];
int check2[has_copy_constructor<HasDeletedCopy>::value? -1 : 1];
int check3[has_copy_constructor<HasPrivateCopy>::value? -1 : 1];
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/p9.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template <int> int f(int); // expected-note 2{{candidate}}
template <signed char> int f(int); // expected-note 2{{candidate}}
int i1 = f<1>(0); // expected-error{{ambiguous}}
int i2 = f<1000>(0); // expected-error{{ambiguous}}
namespace PR6707 {
template<typename T, T Value>
struct X { };
template<typename T, T Value>
void f(X<T, Value>);
void g(X<int, 10> x) {
f(x);
}
static const unsigned char ten = 10;
template<typename T, T Value, typename U>
void f2(X<T, Value>, X<U, Value>);
void g2() {
f2(X<int, 10>(), X<char, ten>());
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/sfinae-1.cpp
|
// RUN: %clang_cc1 -verify %s
// expected-no-diagnostics
typedef char one_byte;
struct two_bytes { char data[2]; };
template<typename T> one_byte __is_class_check(int T::*);
template<typename T> two_bytes __is_class_check(...);
template<typename T> struct is_class {
static const bool value = sizeof(__is_class_check<T>(0)) == 1;
};
struct X { };
int array0[is_class<X>::value? 1 : -1];
int array1[is_class<int>::value? -1 : 1];
int array2[is_class<char[3]>::value? -1 : 1];
namespace instantiation_order1 {
template<typename T>
struct it_is_a_trap {
typedef typename T::trap type;
};
template<bool, typename T = void>
struct enable_if {
typedef T type;
};
template<typename T>
struct enable_if<false, T> { };
template<typename T>
typename enable_if<sizeof(T) == 17>::type
f(const T&, typename it_is_a_trap<T>::type* = 0);
void f(...);
void test_f() {
f('a');
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.funcaddr/p1.cpp
|
// RUN: %clang_cc1 -fsyntax-only %s
template<typename T>
T f0(T, int);
void test_f0() {
int (*f0a)(int, int) = f0;
int (*f0b)(int, int) = &f0;
float (*f0c)(float, int) = &f0;
}
template<typename T> T f1(T, int);
template<typename T> T f1(T);
void test_f1() {
float (*f1a)(float, int) = f1;
float (*f1b)(float, int) = &f1;
float (*f1c)(float) = f1;
float (*f1d)(float) = (f1);
float (*f1e)(float) = &f1;
float (*f1f)(float) = (&f1);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p2-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
// If type deduction cannot be done for any P/A pair, or if for any
// pair the deduction leads to more than one possible set of deduced
// values, or if different pairs yield different deduced values, or if
// any template argument remains neither deduced nor explicitly
// specified, template argument deduction fails.
template<typename ...> struct tuple;
template<typename T, typename U>
struct same_tuple {
static const bool value = false;
};
template<typename ...Types1>
struct same_tuple<tuple<Types1...>, tuple<Types1...> > {
static const bool value = true;
};
int same_tuple_check1[same_tuple<tuple<int, float>, tuple<int, double>>::value? -1 : 1];
int same_tuple_check2[same_tuple<tuple<float, double>, tuple<float, double>>::value? 1 : -1];
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p8-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
// Deductions specific to C++0x.
template<typename T>
struct member_pointer_kind {
static const unsigned value = 0;
};
template<class C, typename R, typename ...Args>
struct member_pointer_kind<R (C::*)(Args...)> {
static const unsigned value = 1;
};
template<class C, typename R, typename ...Args>
struct member_pointer_kind<R (C::*)(Args...) &> {
static const unsigned value = 2;
};
template<class C, typename R, typename ...Args>
struct member_pointer_kind<R (C::*)(Args...) &&> {
static const unsigned value = 3;
};
template<class C, typename R, typename ...Args>
struct member_pointer_kind<R (C::*)(Args...) const> {
static const unsigned value = 4;
};
template<class C, typename R, typename ...Args>
struct member_pointer_kind<R (C::*)(Args...) const &> {
static const unsigned value = 5;
};
template<class C, typename R, typename ...Args>
struct member_pointer_kind<R (C::*)(Args...) const &&> {
static const unsigned value = 6;
};
struct X { };
static_assert(member_pointer_kind<int (X::*)(int)>::value == 1, "");
static_assert(member_pointer_kind<int (X::*)(int) &>::value == 2, "");
static_assert(member_pointer_kind<int (X::*)(int) &&>::value == 3, "");
static_assert(member_pointer_kind<int (X::*)(int) const>::value == 4, "");
static_assert(member_pointer_kind<int (X::*)(int) const&>::value == 5, "");
static_assert(member_pointer_kind<int (X::*)(int) const&&>::value == 6, "");
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p21.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
// Note: Template argument deduction involving parameter packs
// (14.5.3) can deduce zero or more arguments for each parameter pack.
template<class> struct X {
static const unsigned value = 0;
};
template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> {
static const unsigned value = 1;
};
template<class ... Types> struct Y {
static const unsigned value = 0;
};
template<class T, class ... Types> struct Y<T, Types& ...> {
static const unsigned value = 1;
};
template<class ... Types> int f(void (*)(Types ...));
void g(int, float);
int check0[X<int>::value == 0? 1 : -1]; // uses primary template
int check1[X<int(int, float, double)>::value == 1? 1 : -1]; // uses partial specialization
int check2[X<int(float, int)>::value == 0? 1 : -1]; // uses primary template
int check3[Y<>::value == 0? 1 : -1]; // uses primary template
int check4[Y<int&, float&, double&>::value == 1? 1 : -1]; // uses partial specialization
int check5[Y<int, float, double>::value == 0? 1 : -1]; // uses primary template
int fv = f(g); // okay
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p9-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
template<typename ...Types> struct tuple;
template<unsigned> struct unsigned_c;
template<typename T, typename U>
struct is_same {
static const bool value = false;
};
template<typename T>
struct is_same<T, T> {
static const bool value = true;
};
namespace PackExpansionNotAtEnd {
template<typename T, typename U>
struct tuple_same_with_int {
static const bool value = false;
};
template<typename ...Types>
struct tuple_same_with_int<tuple<Types...>, tuple<Types..., int>> {
static const bool value = true;
};
int tuple_same_with_int_1[tuple_same_with_int<tuple<int, float, double>,
tuple<int, float, double, int>
>::value? 1 : -1];
template<typename ... Types> struct UselessPartialSpec;
template<typename ... Types, // expected-note{{non-deducible template parameter 'Types'}}
typename Tail> // expected-note{{non-deducible template parameter 'Tail'}}
struct UselessPartialSpec<Types..., Tail>; // expected-warning{{class template partial specialization contains template parameters that cannot be deduced; this partial specialization will never be used}}
}
namespace DeduceNonTypeTemplateArgsInArray {
template<typename ...ArrayTypes>
struct split_arrays;
template<typename ...ElementTypes, unsigned ...Bounds>
struct split_arrays<ElementTypes[Bounds]...> {
typedef tuple<ElementTypes...> element_types;
// FIXME: Would like to have unsigned_tuple<Bounds...> here.
typedef tuple<unsigned_c<Bounds>...> bounds_types;
};
int check1[is_same<split_arrays<int[1], float[2], double[3]>::element_types,
tuple<int, float, double>>::value? 1 : -1];
int check2[is_same<split_arrays<int[1], float[2], double[3]>::bounds_types,
tuple<unsigned_c<1>, unsigned_c<2>, unsigned_c<3>>
>::value? 1 : -1];
}
namespace DeduceWithDefaultArgs {
template<template<typename...> class Container> void f(Container<int>); // expected-note {{substitution failure [with Container = X]}}
template<typename, typename = int> struct X {};
void g() {
// OK, use default argument for the second template parameter.
f(X<int>{});
f(X<int, int>{});
// Not OK.
f(X<int, double>{}); // expected-error {{no matching function for call to 'f'}}
}
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p5-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
// FIXME: More bullets to go!
template<typename T, typename U>
struct has_nondeduced_pack_test {
static const bool value = false;
};
template<typename R, typename FirstType, typename ...Types>
struct has_nondeduced_pack_test<R(FirstType, Types..., int),
R(FirstType, Types...)> {
static const bool value = true;
};
// - A function parameter pack that does not occur at the end of the
// parameter-declaration-clause.
int check_nondeduced_pack_test0[
has_nondeduced_pack_test<int(float, double, int),
int(float, double)>::value? 1 : -1];
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p10-0x.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
template<typename T> void f(T&&);
template<> void f(int&) { }
void (*fp)(int&) = &f;
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p17.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<int i> class A { };
template<short s> void f(A<s>); // expected-note{{candidate template ignored: substitution failure}}
void k1() {
A<1> a;
f(a); // expected-error{{no matching function for call}}
f<1>(a);
}
template<const short cs> class B { };
template<short s> void g(B<s>);
void k2() {
B<1> b;
g(b); // OK: cv-qualifiers are ignored on template parameter types
}
template<short s> void h(int (&)[s]); // expected-note{{candidate function template not viable: requires 1 argument, but 2 were provided}}
void k3() {
int array[5];
h(array);
h<5>(array);
}
template<short s> void h(int (&)[s], A<s>); // expected-note{{candidate template ignored: substitution failure}}
void k4() {
A<5> a;
int array[5];
h(array, a); // expected-error{{no matching function for call}}
h<5>(array, a);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/p22.cpp
|
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
// expected-no-diagnostics
// If the original function parameter associated with A is a function
// parameter pack and the function parameter associated with P is not
// a function parameter pack, then template argument deduction fails.
template<class ... Args> int& f(Args ... args);
template<class T1, class ... Args> float& f(T1 a1, Args ... args);
template<class T1, class T2> double& f(T1 a1, T2 a2);
void test_f() {
int &ir1 = f();
float &fr1 = f(1, 2, 3);
double &dr1 = f(1, 2);
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p4.cpp
|
// RUN: %clang_cc1 -fsyntax-only %s
struct AnyT {
template<typename T>
operator T();
};
void test_cvqual_ref(AnyT any) {
const int &cir = any;
}
struct AnyThreeLevelPtr {
template<typename T>
operator T***() const
{
T x = 0;
// FIXME: looks like we get this wrong, too!
// x = 0; // will fail if T is deduced to a const type
// (EDG and GCC get this wrong)
return 0;
}
};
struct X { };
void test_deduce_with_qual(AnyThreeLevelPtr a3) {
int * const * const * const ip = a3;
}
struct AnyPtrMem {
template<typename Class, typename T>
operator T Class::*() const
{
T x = 0;
// FIXME: looks like we get this wrong, too!
// x = 0; // will fail if T is deduced to a const type.
// (EDG and GCC get this wrong)
return 0;
}
};
void test_deduce_ptrmem_with_qual(AnyPtrMem apm) {
const float X::* pm = apm;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p3.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
struct AnyPtr {
template<typename T>
operator T*() const;
};
// If A is a cv-qualified type, the top level cv-qualifiers of A's type
// are ignored for type deduction.
void test_cvquals(AnyPtr ap) {
int* const ip = ap;
const float * const volatile fp = ap;
}
// If A is a reference type, the type referred to by A is used for
// type deduction.
void test_ref_arg(AnyPtr ap) {
const int* const &ip = ap;
double * const &dp = ap;
}
struct AnyRef {
template<typename T>
operator T&() const;
};
void test_ref_param(AnyRef ar) {
int &ir = ar;
const float &fr = ar;
int i = ar;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.conv/p2.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
// expected-no-diagnostics
// FIXME: [temp.deduct.conv]p2 bullets 1 and 2 can't actually happen without
// references?
// struct ConvertibleToArray {
// // template<typename T, unsigned N>
// // operator T(()[]) const;
// private:
// typedef int array[17];
// operator array() const;
// };
// void test_array(ConvertibleToArray cta) {
// int *ip = cta;
// ip = cta;
// const float *cfp = cta;
// }
// bullet 2
// struct ConvertibleToFunction {
// template<typename T, typename A1, typename A2>
// operator T(A1, A2) const () { };
// };
// bullet 3
struct ConvertibleToCVQuals {
template<typename T>
operator T* const() const;
};
void test_cvqual_conv(ConvertibleToCVQuals ctcv) {
int *ip = ctcv;
const int *icp = ctcv;
}
|
0 |
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct
|
repos/DirectXShaderCompiler/tools/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.call/basic.cpp
|
// RUN: %clang_cc1 -fsyntax-only -verify %s
template<typename T> struct A { };
template<typename T> A<T> f0(T*);
void test_f0(int *ip, float const *cfp) {
A<int> a0 = f0(ip);
A<const float> a1 = f0(cfp);
}
template<typename T> void f1(T*, int);
void test_f1(int *ip, float fv) {
f1(ip, fv);
}
template<typename T> void f2(T*, T*); // expected-note {{candidate template ignored: could not match 'T *' against 'ConvToIntPtr'}} \
// expected-note{{candidate template ignored: deduced conflicting types for parameter 'T' ('int' vs. 'float')}}
struct ConvToIntPtr {
operator int*() const;
};
void test_f2(int *ip, float *fp) {
f2(ip, ConvToIntPtr()); // expected-error{{no matching function}}
f2(ip, ip); // okay
f2(ip, fp); // expected-error{{no matching function}}
}
namespace test3 {
template<typename T>
struct bar { };
template<typename T>
struct foo {
operator bar<T>();
};
template<typename T>
void func(bar<T>) { // expected-note {{candidate template ignored: could not match 'bar' against 'foo'}}
}
void test() {
func(foo<int>()); // expected-error {{no matching function}}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.