43edb32f1f
analysis to separate dependent names from non-dependent names. For
dependent names, we'll behave differently from Visual C++:
- For __if_exists/__if_not_exists at class scope, we'll just warn
and then ignore them.
- For __if_exists/__if_not_exists in statements, we'll treat the
inner statement as a compound statement, which we only instantiate
in templates where the dependent name (after instantiation)
exists. This behavior is different from VC++, but it's as close as
we can get without encroaching ridiculousness.
The latter part (dependent statements) is not yet implemented.
llvm-svn: 142864
54 lines
938 B
C++
54 lines
938 B
C++
// RUN: %clang_cc1 -fms-extensions %s -verify
|
|
|
|
struct Nontemplate {
|
|
typedef int type;
|
|
};
|
|
|
|
template<typename T>
|
|
struct X {
|
|
__if_exists(Nontemplate::type) {
|
|
typedef Nontemplate::type type;
|
|
}
|
|
|
|
__if_exists(Nontemplate::value) {
|
|
typedef Nontemplate::value type2;
|
|
}
|
|
|
|
__if_not_exists(Nontemplate::value) {
|
|
typedef int type3;
|
|
}
|
|
|
|
__if_exists(T::X) { // expected-warning{{dependent __if_exists declarations are ignored}}
|
|
typedef T::X type4;
|
|
}
|
|
};
|
|
|
|
X<int>::type i1;
|
|
X<int>::type2 i2; // expected-error{{no type named 'type2' in 'X<int>'}}
|
|
X<int>::type3 i3;
|
|
X<int>::type4 i4; // expected-error{{no type named 'type4' in 'X<int>'}}
|
|
|
|
struct HasFoo {
|
|
void foo();
|
|
};
|
|
struct HasBar {
|
|
void bar(int);
|
|
void bar(float);
|
|
};
|
|
|
|
template<typename T>
|
|
void f(T t) {
|
|
__if_exists(T::foo) {
|
|
{ }
|
|
t.foo();
|
|
}
|
|
|
|
__if_not_exists(T::bar) {
|
|
int *i = t;
|
|
{ }
|
|
}
|
|
}
|
|
|
|
template void f(HasFoo);
|
|
template void f(HasBar);
|