mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2025-01-15 12:39:19 +00:00
9b973483ed
The added test case was triggering assertion > Assertion failed: (!SpecializedTemplate.is<SpecializedPartialSpecialization*>() && "Already set to a class template partial specialization!"), function setInstantiationOf, file clang/include/clang/AST/DeclTemplate.h, line 1825. It was happening with ClassTemplateSpecializationDecl `enable_if_not_same<int, int>`. Because this template is specialized for equal types not to have a definition, it wasn't instantiated and its specialization kind remained TSK_Undeclared. And because it was implicit instantiation, we didn't mark the decl as invalid. So when we try to find the best matching partial specialization the second time, we hit the assertion as partial specialization is already set. Fix by reusing stored partial specialization when available, instead of looking for the best match every time. rdar://problem/39524996 Reviewers: rsmith, arphaman Reviewed By: rsmith Subscribers: cfe-commits Differential Revision: https://reviews.llvm.org/D46909 llvm-svn: 332509
101 lines
2.2 KiB
C++
101 lines
2.2 KiB
C++
// RUN: %clang_cc1 -fsyntax-only -verify %s
|
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++98 %s
|
|
// RUN: %clang_cc1 -fsyntax-only -verify -std=c++11 %s
|
|
|
|
// PR4607
|
|
template <class T> struct X {};
|
|
|
|
template <> struct X<char>
|
|
{
|
|
static char* g();
|
|
};
|
|
|
|
template <class T> struct X2 {};
|
|
|
|
template <class U>
|
|
struct X2<U*> {
|
|
static void f() {
|
|
X<U>::g();
|
|
}
|
|
};
|
|
|
|
void a(char *a, char *b) {X2<char*>::f();}
|
|
|
|
namespace WonkyAccess {
|
|
template<typename T>
|
|
struct X {
|
|
int m;
|
|
};
|
|
|
|
template<typename U>
|
|
class Y;
|
|
|
|
template<typename U>
|
|
struct Y<U*> : X<U> { };
|
|
|
|
template<>
|
|
struct Y<float*> : X<float> { };
|
|
|
|
int f(Y<int*> y, Y<float*> y2) {
|
|
return y.m + y2.m;
|
|
}
|
|
}
|
|
|
|
// <rdar://problem/9169404>
|
|
namespace rdar9169404 {
|
|
template<typename T, T N> struct X { };
|
|
template<bool C> struct X<bool, C> {
|
|
typedef int type;
|
|
};
|
|
|
|
X<bool, -1>::type value;
|
|
#if __cplusplus >= 201103L
|
|
// expected-error@-2 {{non-type template argument evaluates to -1, which cannot be narrowed to type 'bool'}}
|
|
#else
|
|
// expected-no-diagnostics
|
|
#endif
|
|
}
|
|
|
|
// rdar://problem/39524996
|
|
namespace rdar39524996 {
|
|
template <typename T, typename U>
|
|
struct enable_if_not_same
|
|
{
|
|
typedef void type;
|
|
};
|
|
template <typename T>
|
|
struct enable_if_not_same<T, T>;
|
|
|
|
template <typename T>
|
|
struct Wrapper {
|
|
// Assertion triggered on trying to set twice the same partial specialization
|
|
// enable_if_not_same<int, int>
|
|
template <class U>
|
|
Wrapper(const Wrapper<U>& other,
|
|
typename enable_if_not_same<U, T>::type* = 0) {}
|
|
|
|
explicit Wrapper(int i) {}
|
|
};
|
|
|
|
template <class T>
|
|
struct Container {
|
|
// It is important that the struct has implicit copy and move constructors.
|
|
Container() : x() {}
|
|
|
|
template <class U>
|
|
Container(const Container<U>& other) : x(static_cast<T>(other.x)) {}
|
|
|
|
// Implicit constructors are member-wise, so the field triggers instantiation
|
|
// of T constructors and we instantiate all of them for overloading purposes.
|
|
T x;
|
|
};
|
|
|
|
void takesWrapperInContainer(const Container< Wrapper<int> >& c);
|
|
void test() {
|
|
// Type mismatch triggers initialization with conversion which requires
|
|
// implicit constructors to be instantiated.
|
|
Container<int> c;
|
|
takesWrapperInContainer(c);
|
|
}
|
|
}
|