mirror of
https://github.com/capstone-engine/llvm-capstone.git
synced 2024-11-24 06:10:12 +00:00
c4fb7720ce
Fix bogus diagnostics that would get confused and think a "no viable fuctions" case was an "undeclared identifiers" case, resulting in an incorrect diagnostic preceding the correct one. Use overload resolution to determine which function we should select when we can find call candidates from a dependent base class. Make the diagnostics for a call that could call a function from a dependent base class more specific, and use a different diagnostic message for the case where the call target is instead declared later in the same class. Plus some minor diagnostic wording improvements.
68 lines
2.2 KiB
C++
68 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
|
|
|
|
// Clang used to crash trying to recover while adding 'this->' before Work(x);
|
|
|
|
template <typename> struct A {
|
|
static void Work(int); // expected-note{{here}}
|
|
};
|
|
|
|
template <typename T> struct B : public A<T> {
|
|
template <typename T2> B(T2 x) {
|
|
Work(x); // expected-error{{explicit qualification required}}
|
|
}
|
|
};
|
|
|
|
void Test() {
|
|
B<int> b(0); // expected-note{{in instantiation of function template}}
|
|
}
|
|
|
|
|
|
// Don't crash here.
|
|
namespace PR16134 {
|
|
template <class P> struct S // expected-error {{expected ';'}}
|
|
template <> static S<Q>::f() // expected-error +{{}}
|
|
}
|
|
|
|
namespace PR16225 {
|
|
template <typename T> void f();
|
|
template <typename C> void g(C*) {
|
|
struct LocalStruct : UnknownBase<Mumble, C> { }; // expected-error {{use of undeclared identifier 'Mumble'}}
|
|
f<LocalStruct>();
|
|
#if __cplusplus <= 199711L
|
|
// expected-warning@-2 {{template argument uses local type 'LocalStruct'}}
|
|
#endif
|
|
struct LocalStruct2 : UnknownBase<C> { }; // expected-error {{no template named 'UnknownBase'}}
|
|
}
|
|
struct S;
|
|
void h() {
|
|
g<S>(0);
|
|
#if __cplusplus <= 199711L
|
|
// expected-note@-2 {{in instantiation of function template specialization}}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
namespace test1 {
|
|
template <typename> class ArraySlice {};
|
|
class Foo;
|
|
class NonTemplateClass {
|
|
void MemberFunction(ArraySlice<Foo>, int);
|
|
template <class T> void MemberFuncTemplate(ArraySlice<T>, int);
|
|
};
|
|
void NonTemplateClass::MemberFunction(ArraySlice<Foo> resource_data,
|
|
int now) {
|
|
// expected-note@+1 {{in instantiation of function template specialization 'test1::NonTemplateClass::MemberFuncTemplate<test1::Foo>'}}
|
|
MemberFuncTemplate(resource_data, now);
|
|
}
|
|
template <class T>
|
|
void NonTemplateClass::MemberFuncTemplate(ArraySlice<T> resource_data, int) {
|
|
// expected-error@+1 {{member 'UndeclaredMethod' used before its declaration}}
|
|
UndeclaredMethod(resource_data);
|
|
}
|
|
// expected-error@+2 {{out-of-line definition of 'UndeclaredMethod' does not match any declaration}}
|
|
// expected-note@+1 {{member is declared here}}
|
|
void NonTemplateClass::UndeclaredMethod() {}
|
|
}
|