llvm-project/clang/test/SemaCXX/attr-exclude_from_explicit_instantiation.explicit_instantiation.cpp
Louis Dionne d269579a97 [clang] Add the exclude_from_explicit_instantiation attribute
Summary:
This attribute allows excluding a member of a class template from being part
of an explicit template instantiation of that class template. This also makes
sure that code using such a member will not take for granted that an external
instantiation exists in another translation unit. The attribute was discussed
on cfe-dev at [1] and is primarily motivated by the removal of always_inline
in libc++ to control what's part of the ABI (see links in [1]).

[1]: http://lists.llvm.org/pipermail/cfe-dev/2018-August/059024.html

rdar://problem/43428125

Reviewers: rsmith

Subscribers: dexonsmith, cfe-commits

Differential Revision: https://reviews.llvm.org/D51789

llvm-svn: 343790
2018-10-04 15:49:42 +00:00

46 lines
1.5 KiB
C++

// RUN: %clang_cc1 -fsyntax-only -verify %s
// Test that explicit instantiations do not instantiate entities
// marked with the exclude_from_explicit_instantiation attribute.
#define EXCLUDE_FROM_EXPLICIT_INSTANTIATION __attribute__((exclude_from_explicit_instantiation))
template <class T>
struct Foo {
EXCLUDE_FROM_EXPLICIT_INSTANTIATION inline void non_static_member_function1();
EXCLUDE_FROM_EXPLICIT_INSTANTIATION void non_static_member_function2();
EXCLUDE_FROM_EXPLICIT_INSTANTIATION static inline void static_member_function1();
EXCLUDE_FROM_EXPLICIT_INSTANTIATION static void static_member_function2();
EXCLUDE_FROM_EXPLICIT_INSTANTIATION static int static_data_member;
struct EXCLUDE_FROM_EXPLICIT_INSTANTIATION member_class1 {
static void non_static_member_function() { using Fail = typename T::fail; }
};
struct member_class2 {
EXCLUDE_FROM_EXPLICIT_INSTANTIATION static void non_static_member_function() { using Fail = typename T::fail; }
};
};
template <class T>
inline void Foo<T>::non_static_member_function1() { using Fail = typename T::fail; }
template <class T>
void Foo<T>::non_static_member_function2() { using Fail = typename T::fail; }
template <class T>
inline void Foo<T>::static_member_function1() { using Fail = typename T::fail; }
template <class T>
void Foo<T>::static_member_function2() { using Fail = typename T::fail; }
template <class T>
int Foo<T>::static_data_member = T::fail;
// expected-no-diagnostics
template struct Foo<int>;