ead1690d31
These changes make the Clang parser recognize expression parameter pack expansion and initializer lists in attribute arguments. Because expression parameter pack expansion requires additional handling while creating and instantiating templates, the support for them must be explicitly supported through the AcceptsExprPack flag. Handling expression pack expansions may require a delay to when the arguments of an attribute are correctly populated. To this end, attributes that are set to accept these - through setting the AcceptsExprPack flag - will automatically have an additional variadic expression argument member named DelayedArgs. This member is not exposed the same way other arguments are but is set through the new CreateWithDelayedArgs creator function generated for applicable attributes. To illustrate how to implement support for expression pack expansion support, clang::annotate is made to support pack expansions. This is done by making handleAnnotationAttr delay setting the actual attribute arguments until after template instantiation if it was unable to populate the arguments due to dependencies in the parsed expressions.
424 lines
19 KiB
C++
424 lines
19 KiB
C++
// RUN: %clang_cc1 -fcxx-exceptions -fdeclspec -fexceptions -fsyntax-only -verify -std=c++11 -Wc++14-compat -Wc++14-extensions -Wc++17-extensions %s
|
|
|
|
// Need std::initializer_list
|
|
namespace std {
|
|
typedef decltype(sizeof(int)) size_t;
|
|
|
|
// libc++'s implementation
|
|
template <class _E>
|
|
class initializer_list
|
|
{
|
|
const _E* __begin_;
|
|
size_t __size_;
|
|
|
|
initializer_list(const _E* __b, size_t __s)
|
|
: __begin_(__b),
|
|
__size_(__s)
|
|
{}
|
|
|
|
public:
|
|
typedef _E value_type;
|
|
typedef const _E& reference;
|
|
typedef const _E& const_reference;
|
|
typedef size_t size_type;
|
|
|
|
typedef const _E* iterator;
|
|
typedef const _E* const_iterator;
|
|
|
|
initializer_list() : __begin_(nullptr), __size_(0) {}
|
|
|
|
size_t size() const {return __size_;}
|
|
const _E* begin() const {return __begin_;}
|
|
const _E* end() const {return __begin_ + __size_;}
|
|
};
|
|
}
|
|
|
|
|
|
// Declaration syntax checks
|
|
[[]] int before_attr;
|
|
int [[]] between_attr;
|
|
const [[]] int between_attr_2 = 0; // expected-error {{an attribute list cannot appear here}}
|
|
int after_attr [[]];
|
|
int * [[]] ptr_attr;
|
|
int & [[]] ref_attr = after_attr;
|
|
int & [[unknown]] ref_attr_2 = after_attr; // expected-warning {{unknown attribute 'unknown' ignored}}
|
|
int & [[noreturn]] ref_attr_3 = after_attr; // expected-error {{'noreturn' attribute cannot be applied to types}}
|
|
int && [[]] rref_attr = 0;
|
|
int array_attr [1] [[]];
|
|
alignas(8) int aligned_attr;
|
|
[[test::valid(for 42 [very] **** '+' symbols went on a trip and had a "good"_time; the end.)]] int garbage_attr; // expected-warning {{unknown attribute 'valid' ignored}}
|
|
[[,,,static, class, namespace,, inline, constexpr, mutable,, bitand, bitor::compl(!.*_ Cx.!U^*R),,,]] int more_garbage_attr; // expected-warning {{unknown attribute 'static' ignored}} \
|
|
// expected-warning {{unknown attribute 'class' ignored}} \
|
|
// expected-warning {{unknown attribute 'namespace' ignored}} \
|
|
// expected-warning {{unknown attribute 'inline' ignored}} \
|
|
// expected-warning {{unknown attribute 'constexpr' ignored}} \
|
|
// expected-warning {{unknown attribute 'mutable' ignored}} \
|
|
// expected-warning {{unknown attribute 'bitand' ignored}} \
|
|
// expected-warning {{unknown attribute 'compl' ignored}}
|
|
[[u8"invalid!"]] int invalid_string_attr; // expected-error {{expected ']'}}
|
|
void fn_attr () [[]];
|
|
void noexcept_fn_attr () noexcept [[]];
|
|
struct MemberFnOrder {
|
|
virtual void f() const volatile && noexcept [[]] final = 0;
|
|
};
|
|
struct [[]] struct_attr;
|
|
class [[]] class_attr {};
|
|
union [[]] union_attr;
|
|
enum [[]] E { };
|
|
namespace test_misplacement {
|
|
[[]] struct struct_attr2; //expected-error{{misplaced attributes}}
|
|
[[]] class class_attr2; //expected-error{{misplaced attributes}}
|
|
[[]] union union_attr2; //expected-error{{misplaced attributes}}
|
|
[[]] enum E2 { }; //expected-error{{misplaced attributes}}
|
|
}
|
|
|
|
// Checks attributes placed at wrong syntactic locations of class specifiers.
|
|
class [[]] [[]]
|
|
attr_after_class_name_decl [[]] [[]]; // expected-error {{an attribute list cannot appear here}}
|
|
|
|
class [[]] [[]]
|
|
attr_after_class_name_definition [[]] [[]] [[]]{}; // expected-error {{an attribute list cannot appear here}}
|
|
|
|
class [[]] c {};
|
|
class c [[]] [[]] x;
|
|
class c [[]] [[]] y [[]] [[]];
|
|
class c final [(int){0}];
|
|
|
|
class base {};
|
|
class [[]] [[]] final_class
|
|
alignas(float) [[]] final // expected-error {{an attribute list cannot appear here}}
|
|
alignas(float) [[]] [[]] alignas(float): base{}; // expected-error {{an attribute list cannot appear here}}
|
|
|
|
class [[]] [[]] final_class_another
|
|
[[]] [[]] alignas(16) final // expected-error {{an attribute list cannot appear here}}
|
|
[[]] [[]] alignas(16) [[]]{}; // expected-error {{an attribute list cannot appear here}}
|
|
|
|
// The diagnostics here don't matter much, this just shouldn't crash:
|
|
class C final [[deprecated(l]] {}); // expected-error {{use of undeclared identifier}} expected-error {{expected ']'}} expected-error {{an attribute list cannot appear here}} expected-error {{expected unqualified-id}}
|
|
class D final alignas ([l) {}]{}); // expected-error {{expected ',' or ']' in lambda capture list}} expected-error {{an attribute list cannot appear here}}
|
|
|
|
[[]] struct with_init_declarators {} init_declarator;
|
|
[[]] struct no_init_declarators; // expected-error {{misplaced attributes}}
|
|
template<typename> [[]] struct no_init_declarators_template; // expected-error {{an attribute list cannot appear here}}
|
|
void fn_with_structs() {
|
|
[[]] struct with_init_declarators {} init_declarator;
|
|
[[]] struct no_init_declarators; // expected-error {{an attribute list cannot appear here}}
|
|
}
|
|
[[]];
|
|
struct ctordtor {
|
|
[[]] ctordtor [[]] () [[]];
|
|
ctordtor (C) [[]];
|
|
[[]] ~ctordtor [[]] () [[]];
|
|
};
|
|
[[]] ctordtor::ctordtor [[]] () [[]] {}
|
|
[[]] ctordtor::ctordtor (C) [[]] try {} catch (...) {}
|
|
[[]] ctordtor::~ctordtor [[]] () [[]] {}
|
|
extern "C++" [[]] int extern_attr;
|
|
template <typename T> [[]] void template_attr ();
|
|
[[]] [[]] int [[]] [[]] multi_attr [[]] [[]];
|
|
|
|
int comma_attr [[,]];
|
|
int scope_attr [[foo::]]; // expected-error {{expected identifier}}
|
|
int (paren_attr) [[]]; // expected-error {{an attribute list cannot appear here}}
|
|
unsigned [[]] int attr_in_decl_spec; // expected-error {{an attribute list cannot appear here}}
|
|
unsigned [[]] int [[]] const double_decl_spec = 0; // expected-error 2{{an attribute list cannot appear here}}
|
|
class foo {
|
|
void const_after_attr () [[]] const; // expected-error {{expected ';'}}
|
|
};
|
|
extern "C++" [[]] { } // expected-error {{an attribute list cannot appear here}}
|
|
[[]] template <typename T> void before_template_attr (); // expected-error {{an attribute list cannot appear here}}
|
|
[[]] namespace ns { int i; } // expected-error {{an attribute list cannot appear here}} expected-note {{declared here}}
|
|
[[]] static_assert(true, ""); //expected-error {{an attribute list cannot appear here}}
|
|
[[]] asm(""); // expected-error {{an attribute list cannot appear here}}
|
|
|
|
[[]] using ns::i;
|
|
[[unknown]] using namespace ns; // expected-warning {{unknown attribute 'unknown' ignored}}
|
|
[[noreturn]] using namespace ns; // expected-error {{'noreturn' attribute only applies to functions}}
|
|
namespace [[]] ns2 {} // expected-warning {{attributes on a namespace declaration are a C++17 extension}}
|
|
|
|
using[[]] alignas(4)[[]] ns::i; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to variables, data members and tag types}} expected-warning {{ISO C++}}
|
|
using [[]] alignas(4) [[]] foobar = int; // expected-error {{an attribute list cannot appear here}} expected-error {{'alignas' attribute only applies to}}
|
|
|
|
void bad_attributes_in_do_while() {
|
|
do {} while (
|
|
[[ns::i); // expected-error {{expected ']'}} \
|
|
// expected-note {{to match this '['}} \
|
|
// expected-error {{expected expression}}
|
|
do {} while (
|
|
[[a]b ns::i); // expected-error {{expected ']'}} \
|
|
// expected-note {{to match this '['}} \
|
|
// expected-error {{expected expression}}
|
|
do {} while (
|
|
[[ab]ab] ns::i); // expected-error {{an attribute list cannot appear here}}
|
|
do {} while ( // expected-note {{to match this '('}}
|
|
alignas(4 ns::i; // expected-note {{to match this '('}}
|
|
// expected-error@-1 {{expected ';' after do/while}}
|
|
} // expected-error 2{{expected ')'}} expected-error {{expected expression}}
|
|
|
|
[[]] using T = int; // expected-error {{an attribute list cannot appear here}}
|
|
using T [[]] = int; // ok
|
|
template<typename T> using U [[]] = T;
|
|
using ns::i [[]];
|
|
using ns::i [[]], ns::i [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}}
|
|
struct using_in_struct_base {
|
|
typedef int i, j, k, l;
|
|
};
|
|
struct using_in_struct : using_in_struct_base {
|
|
[[]] using using_in_struct_base::i;
|
|
using using_in_struct_base::j [[]];
|
|
[[]] using using_in_struct_base::k [[]], using_in_struct_base::l [[]]; // expected-warning {{use of multiple declarators in a single using declaration is a C++17 extension}}
|
|
};
|
|
using [[]] ns::i; // expected-error {{an attribute list cannot appear here}}
|
|
using T [[unknown]] = int; // expected-warning {{unknown attribute 'unknown' ignored}}
|
|
using T [[noreturn]] = int; // expected-error {{'noreturn' attribute only applies to functions}}
|
|
using V = int; // expected-note {{previous}}
|
|
using V [[gnu::vector_size(16)]] = int; // expected-error {{redefinition with different types}}
|
|
|
|
auto trailing() -> [[]] const int; // expected-error {{an attribute list cannot appear here}}
|
|
auto trailing() -> const [[]] int; // expected-error {{an attribute list cannot appear here}}
|
|
auto trailing() -> const int [[]];
|
|
auto trailing_2() -> struct struct_attr [[]];
|
|
|
|
namespace N {
|
|
struct S {};
|
|
};
|
|
template<typename> struct Template {};
|
|
|
|
// FIXME: Improve this diagnostic
|
|
struct [[]] N::S s; // expected-error {{an attribute list cannot appear here}}
|
|
struct [[]] Template<int> t; // expected-error {{an attribute list cannot appear here}}
|
|
struct [[]] ::template Template<int> u; // expected-error {{an attribute list cannot appear here}}
|
|
template struct [[]] Template<char>; // expected-error {{an attribute list cannot appear here}}
|
|
template struct __attribute__((pure)) Template<std::size_t>; // We still allow GNU-style attributes here
|
|
template <> struct [[]] Template<void>;
|
|
|
|
enum [[]] E1 {};
|
|
enum [[]] E2; // expected-error {{forbids forward references}}
|
|
enum [[]] E1;
|
|
enum [[]] E3 : int;
|
|
enum [[]] {
|
|
k_123 [[]] = 123 // expected-warning {{attributes on an enumerator declaration are a C++17 extension}}
|
|
};
|
|
enum [[]] E1 e; // expected-error {{an attribute list cannot appear here}}
|
|
enum [[]] class E4 { }; // expected-error {{an attribute list cannot appear here}}
|
|
enum struct [[]] E5;
|
|
|
|
struct S {
|
|
friend int f [[]] (); // expected-FIXME{{an attribute list cannot appear here}}
|
|
friend int f1 [[noreturn]] (); //expected-error{{an attribute list cannot appear here}}
|
|
friend int f2 [[]] [[noreturn]] () {}
|
|
[[]] friend int g(); // expected-error{{an attribute list cannot appear here}}
|
|
[[]] friend int h() {
|
|
}
|
|
[[]] friend int f3(), f4(), f5(); // expected-error{{an attribute list cannot appear here}}
|
|
friend int f6 [[noreturn]] (), f7 [[noreturn]] (), f8 [[noreturn]] (); // expected-error3 {{an attribute list cannot appear here}}
|
|
friend class [[]] C; // expected-error{{an attribute list cannot appear here}}
|
|
[[]] friend class D; // expected-error{{an attribute list cannot appear here}}
|
|
[[]] friend int; // expected-error{{an attribute list cannot appear here}}
|
|
};
|
|
template<typename T> void tmpl(T) {}
|
|
template void tmpl [[]] (int); // expected-FIXME {{an attribute list cannot appear here}}
|
|
template [[]] void tmpl(char); // expected-error {{an attribute list cannot appear here}}
|
|
template void [[]] tmpl(short);
|
|
|
|
// Argument tests
|
|
alignas int aligned_no_params; // expected-error {{expected '('}}
|
|
alignas(i) int aligned_nonconst; // expected-error {{'aligned' attribute requires integer constant}} expected-note {{read of non-const variable 'i'}}
|
|
|
|
// Statement tests
|
|
void foo () {
|
|
[[]] ;
|
|
[[]] { }
|
|
[[]] if (0) { }
|
|
[[]] for (;;);
|
|
[[]] do {
|
|
[[]] continue;
|
|
} while (0);
|
|
[[]] while (0);
|
|
|
|
[[]] switch (i) {
|
|
[[]] case 0:
|
|
[[]] default:
|
|
[[]] break;
|
|
}
|
|
|
|
[[]] goto there;
|
|
[[]] there:
|
|
|
|
[[]] try {
|
|
} [[]] catch (...) { // expected-error {{an attribute list cannot appear here}}
|
|
}
|
|
struct S { int arr[2]; } s;
|
|
(void)s.arr[ [] { return 0; }() ]; // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}}
|
|
int n = __builtin_offsetof(S, arr[ [] { return 0; }() ]); // expected-error {{C++11 only allows consecutive left square brackets when introducing an attribute}}
|
|
|
|
void bar [[noreturn]] ([[]] int i, [[]] int j);
|
|
using FuncType = void ([[]] int);
|
|
void baz([[]]...); // expected-error {{expected parameter declarator}}
|
|
|
|
[[]] return;
|
|
}
|
|
|
|
template<typename...Ts> void variadic() {
|
|
void bar [[noreturn...]] (); // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}}
|
|
}
|
|
|
|
template <int... Is> void variadic_nttp() {
|
|
void bar [[noreturn...]] (); // expected-error {{attribute 'noreturn' cannot be used as an attribute pack}}
|
|
void baz [[clang::no_sanitize(Is...)]] (); // expected-error {{attribute 'no_sanitize' does not support argument pack expansion}}
|
|
void bor [[clang::annotate("A", "V" ...)]] (); // expected-error {{pack expansion does not contain any unexpanded parameter packs}}
|
|
void bir [[clang::annotate("B", {1, 2, 3, 4})]] (); // expected-error {{'annotate' attribute requires parameter 1 to be a constant expression}} expected-note {{subexpression not valid in a constant expression}}
|
|
void boo [[unknown::foo(Is...)]] (); // expected-warning {{unknown attribute 'foo' ignored}}
|
|
void faz [[clang::annotate("C", (Is + ...))]] (); // expected-warning {{pack fold expression is a C++17 extension}}
|
|
void far [[clang::annotate("D", Is...)]] ();
|
|
void foz [[clang::annotate("E", 1, 2, 3, Is...)]] ();
|
|
void fiz [[clang::annotate("F", Is..., 1, 2, 3)]] ();
|
|
void fir [[clang::annotate("G", 1, Is..., 2, 3)]] ();
|
|
}
|
|
|
|
// Expression tests
|
|
void bar () {
|
|
// FIXME: GCC accepts [[gnu::noreturn]] on a lambda, even though it appertains
|
|
// to the operator()'s type, and GCC does not otherwise accept attributes
|
|
// applied to types. Use that to test this.
|
|
[] () [[gnu::noreturn]] { return; } (); // expected-warning {{attribute 'noreturn' ignored}} FIXME-error {{should not return}}
|
|
[] () [[gnu::noreturn]] { throw; } (); // expected-warning {{attribute 'noreturn' ignored}}
|
|
new int[42][[]][5][[]]{};
|
|
}
|
|
|
|
// Condition tests
|
|
void baz () {
|
|
if ([[unknown]] bool b = true) { // expected-warning {{unknown attribute 'unknown' ignored}}
|
|
switch ([[unknown]] int n { 42 }) { // expected-warning {{unknown attribute 'unknown' ignored}}
|
|
default:
|
|
for ([[unknown]] int n = 0; [[unknown]] char b = n < 5; ++b) { // expected-warning 2{{unknown attribute 'unknown' ignored}}
|
|
}
|
|
}
|
|
}
|
|
int x;
|
|
// An attribute can be applied to an expression-statement, such as the first
|
|
// statement in a for. But it can't be applied to a condition which is an
|
|
// expression.
|
|
for ([[]] x = 0; ; ) {} // expected-error {{an attribute list cannot appear here}}
|
|
for (; [[]] x < 5; ) {} // expected-error {{an attribute list cannot appear here}}
|
|
while ([[]] bool k { false }) {
|
|
}
|
|
while ([[]] true) { // expected-error {{an attribute list cannot appear here}}
|
|
}
|
|
do {
|
|
} while ([[]] false); // expected-error {{an attribute list cannot appear here}}
|
|
|
|
for ([[unknown]] int n : { 1, 2, 3 }) { // expected-warning {{unknown attribute 'unknown' ignored}}
|
|
}
|
|
}
|
|
|
|
enum class __attribute__((visibility("hidden"))) SecretKeepers {
|
|
one, /* rest are deprecated */ two, three
|
|
};
|
|
enum class [[]] EvenMoreSecrets {};
|
|
|
|
namespace arguments {
|
|
void f[[gnu::format(printf, 1, 2)]](const char*, ...);
|
|
void g() [[unknown::foo(ignore arguments for unknown attributes, even with symbols!)]]; // expected-warning {{unknown attribute 'foo' ignored}}
|
|
[[deprecated("with argument")]] int i;
|
|
// expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
|
|
}
|
|
|
|
// Forbid attributes on decl specifiers.
|
|
unsigned [[gnu::used]] static int [[gnu::unused]] v1; // expected-error {{'unused' attribute cannot be applied to types}} \
|
|
expected-error {{an attribute list cannot appear here}}
|
|
typedef [[gnu::used]] unsigned long [[gnu::unused]] v2; // expected-error {{'unused' attribute cannot be applied to types}} \
|
|
expected-error {{an attribute list cannot appear here}}
|
|
int [[carries_dependency]] foo(int [[carries_dependency]] x); // expected-error 2{{'carries_dependency' attribute cannot be applied to types}}
|
|
|
|
// Forbid [[gnu::...]] attributes on declarator chunks.
|
|
int *[[gnu::unused]] v3; // expected-warning {{attribute 'unused' ignored}}
|
|
int v4[2][[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
|
|
int v5()[[gnu::unused]]; // expected-warning {{attribute 'unused' ignored}}
|
|
|
|
[[attribute_declaration]]; // expected-warning {{unknown attribute 'attribute_declaration' ignored}}
|
|
[[noreturn]]; // expected-error {{'noreturn' attribute only applies to functions}}
|
|
[[carries_dependency]]; // expected-error {{'carries_dependency' attribute only applies to parameters, Objective-C methods, and functions}}
|
|
|
|
class A {
|
|
A([[gnu::unused]] int a);
|
|
};
|
|
A::A([[gnu::unused]] int a) {}
|
|
|
|
namespace GccConst {
|
|
// GCC's tokenizer treats const and __const as the same token.
|
|
[[gnu::const]] int *f1();
|
|
[[gnu::__const]] int *f2();
|
|
[[gnu::__const__]] int *f3();
|
|
void f(const int *);
|
|
void g() { f(f1()); f(f2()); }
|
|
void h() { f(f3()); }
|
|
}
|
|
|
|
namespace GccASan {
|
|
__attribute__((no_address_safety_analysis)) void f1();
|
|
__attribute__((no_sanitize_address)) void f2();
|
|
[[gnu::no_address_safety_analysis]] void f3();
|
|
[[gnu::no_sanitize_address]] void f4();
|
|
}
|
|
|
|
namespace {
|
|
[[deprecated]] void bar();
|
|
// expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
|
|
[[deprecated("hello")]] void baz();
|
|
// expected-warning@-1 {{use of the 'deprecated' attribute is a C++14 extension}}
|
|
[[deprecated()]] void foo();
|
|
// expected-error@-1 {{parentheses must be omitted if 'deprecated' attribute's argument list is empty}}
|
|
[[gnu::deprecated()]] void quux();
|
|
}
|
|
|
|
namespace {
|
|
[[ // expected-error {{expected ']'}}
|
|
#pragma pack(pop)
|
|
deprecated
|
|
]] void bad();
|
|
}
|
|
|
|
int fallthru(int n) {
|
|
switch (n) {
|
|
case 0:
|
|
n += 5;
|
|
[[fallthrough]]; // expected-warning {{use of the 'fallthrough' attribute is a C++17 extension}}
|
|
case 1:
|
|
n *= 2;
|
|
break;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
template<typename T> struct TemplateStruct {};
|
|
class FriendClassesWithAttributes {
|
|
// We allow GNU-style attributes here
|
|
template <class _Tp, class _Alloc> friend class __attribute__((__type_visibility__("default"))) vector;
|
|
template <class _Tp, class _Alloc> friend class __declspec(code_seg("foo,whatever")) vector2;
|
|
// But not C++11 ones
|
|
template <class _Tp, class _Alloc> friend class[[]] vector3; // expected-error {{an attribute list cannot appear here}}
|
|
template <class _Tp, class _Alloc> friend class [[clang::__type_visibility__(("default"))]] vector4; // expected-error {{an attribute list cannot appear here}}
|
|
|
|
// Also allowed
|
|
friend struct __attribute__((__type_visibility__("default"))) TemplateStruct<FriendClassesWithAttributes>;
|
|
friend struct __declspec(code_seg("foo,whatever")) TemplateStruct<FriendClassesWithAttributes>;
|
|
friend struct[[]] TemplateStruct<FriendClassesWithAttributes>; // expected-error {{an attribute list cannot appear here}}
|
|
friend struct [[clang::__type_visibility__("default")]] TemplateStruct<FriendClassesWithAttributes>; // expected-error {{an attribute list cannot appear here}}
|
|
};
|
|
|
|
#define attr_name bitand
|
|
#define attr_name_2(x) x
|
|
#define attr_name_3(x, y) x##y
|
|
[[attr_name, attr_name_2(bitor), attr_name_3(com, pl)]] int macro_attrs; // expected-warning {{unknown attribute 'compl' ignored}} \
|
|
expected-warning {{unknown attribute 'bitor' ignored}} \
|
|
expected-warning {{unknown attribute 'bitand' ignored}}
|
|
|
|
// Check that we can parse an attribute in our vendor namespace.
|
|
[[clang::annotate("test")]] void annotate1();
|
|
[[_Clang::annotate("test")]] void annotate2();
|
|
// Note: __clang__ is a predefined macro, which is why _Clang is the
|
|
// prefered "protected" vendor namespace. We support __clang__ only for
|
|
// people expecting it to behave the same as __gnu__.
|
|
[[__clang__::annotate("test")]] void annotate3(); // expected-warning {{'__clang__' is a predefined macro name, not an attribute scope specifier; did you mean '_Clang' instead?}}
|