1 // Test without serialization:
2 // RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++11 -Wno-deprecated-declarations -ast-dump -ast-dump-filter Test %s \
3 // RUN: | FileCheck --strict-whitespace %s
4 //
5 // Test with serialization:
6 // RUN: %clang_cc1 -triple x86_64-pc-linux -std=c++11 -Wno-deprecated-declarations -emit-pch -o %t %s
7 // RUN: %clang_cc1 -x c++ -triple x86_64-pc-linux -std=c++11 -Wno-deprecated-declarations \
8 // RUN: -include-pch %t -ast-dump-all -ast-dump-filter Test /dev/null \
9 // RUN: | sed -e "s/ <undeserialized declarations>//" -e "s/ imported//" \
10 // RUN: | FileCheck --strict-whitespace %s
11
12 int TestLocation
13 __attribute__((unused));
14 // CHECK: VarDecl{{.*}}TestLocation
15 // CHECK-NEXT: UnusedAttr 0x{{[^ ]*}} <line:[[@LINE-2]]:16>
16
17 int TestIndent
18 __attribute__((unused));
19 // CHECK: {{^}}VarDecl{{.*TestIndent[^()]*$}}
20 // CHECK-NEXT: {{^}}`-UnusedAttr{{[^()]*$}}
21
TestAttributedStmt()22 void TestAttributedStmt() {
23 switch (1) {
24 case 1:
25 [[clang::fallthrough]];
26 case 2:
27 ;
28 }
29 }
30 // CHECK: FunctionDecl{{.*}}TestAttributedStmt
31 // CHECK: AttributedStmt
32 // CHECK-NEXT: FallThroughAttr
33 // CHECK-NEXT: NullStmt
34
35 [[clang::warn_unused_result]] int TestCXX11DeclAttr();
36 // CHECK: FunctionDecl{{.*}}TestCXX11DeclAttr
37 // CHECK-NEXT: WarnUnusedResultAttr
38
39 int TestAlignedNull __attribute__((aligned));
40 // CHECK: VarDecl{{.*}}TestAlignedNull
41 // CHECK-NEXT: AlignedAttr {{.*}} aligned
42 // CHECK-NEXT: <<<NULL>>>
43
44 int TestAlignedExpr __attribute__((aligned(4)));
45 // CHECK: VarDecl{{.*}}TestAlignedExpr
46 // CHECK-NEXT: AlignedAttr {{.*}} aligned
47 // CHECK-NEXT: ConstantExpr
48 // CHECK-NEXT: value: Int 4
49 // CHECK-NEXT: IntegerLiteral
50
51 int TestEnum __attribute__((visibility("default")));
52 // CHECK: VarDecl{{.*}}TestEnum
53 // CHECK-NEXT: VisibilityAttr{{.*}} Default
54
55 class __attribute__((lockable)) Mutex {
56 } mu1, mu2;
57 int TestExpr __attribute__((guarded_by(mu1)));
58 // CHECK: VarDecl{{.*}}TestExpr
59 // CHECK-NEXT: GuardedByAttr
60 // CHECK-NEXT: DeclRefExpr{{.*}}mu1
61
62 class Mutex TestVariadicExpr __attribute__((acquired_after(mu1, mu2)));
63 // CHECK: VarDecl{{.*}}TestVariadicExpr
64 // CHECK: AcquiredAfterAttr
65 // CHECK-NEXT: DeclRefExpr{{.*}}mu1
66 // CHECK-NEXT: DeclRefExpr{{.*}}mu2
67
function1(void *)68 void function1(void *) {
69 int TestFunction __attribute__((cleanup(function1)));
70 }
71 // CHECK: VarDecl{{.*}}TestFunction
72 // CHECK-NEXT: CleanupAttr{{.*}} Function{{.*}}function1
73
74 void TestIdentifier(void *, int)
75 __attribute__((pointer_with_type_tag(ident1,1,2)));
76 // CHECK: FunctionDecl{{.*}}TestIdentifier
77 // CHECK: ArgumentWithTypeTagAttr{{.*}} pointer_with_type_tag ident1
78
79 void TestBool(void *, int)
80 __attribute__((pointer_with_type_tag(bool1,1,2)));
81 // CHECK: FunctionDecl{{.*}}TestBool
82 // CHECK: ArgumentWithTypeTagAttr{{.*}}pointer_with_type_tag bool1 1 2 IsPointer
83
84 void TestUnsigned(void *, int)
85 __attribute__((pointer_with_type_tag(unsigned1,1,2)));
86 // CHECK: FunctionDecl{{.*}}TestUnsigned
87 // CHECK: ArgumentWithTypeTagAttr{{.*}} pointer_with_type_tag unsigned1 1 2
88
89 void TestInt(void) __attribute__((constructor(123)));
90 // CHECK: FunctionDecl{{.*}}TestInt
91 // CHECK-NEXT: ConstructorAttr{{.*}} 123
92
93 static int TestString __attribute__((alias("alias1")));
94 // CHECK: VarDecl{{.*}}TestString
95 // CHECK-NEXT: AliasAttr{{.*}} "alias1"
96
97 extern struct s1 TestType
98 __attribute__((type_tag_for_datatype(ident1,int)));
99 // CHECK: VarDecl{{.*}}TestType
100 // CHECK-NEXT: TypeTagForDatatypeAttr{{.*}} int
101
TestLabel()102 void TestLabel() {
103 L: __attribute__((unused)) int i;
104 // CHECK: LabelStmt{{.*}}'L'
105 // CHECK: VarDecl{{.*}}i 'int'
106 // CHECK-NEXT: UnusedAttr{{.*}}
107
108 M: __attribute(()) int j;
109 // CHECK: LabelStmt {{.*}} 'M'
110 // CHECK-NEXT: DeclStmt
111 // CHECK-NEXT: VarDecl {{.*}} j 'int'
112
113 N: __attribute(()) ;
114 // CHECK: LabelStmt {{.*}} 'N'
115 // CHECK-NEXT: NullStmt
116 }
117
118 namespace Test {
119 extern "C" int printf(const char *format, ...);
120 // CHECK: FunctionDecl{{.*}}printf
121 // CHECK-NEXT: ParmVarDecl{{.*}}format{{.*}}'const char *'
122 // CHECK-NEXT: BuiltinAttr{{.*}}Implicit
123 // CHECK-NEXT: FormatAttr{{.*}}Implicit printf 1 2
124
125 alignas(8) extern int x;
126 extern int x;
127 // CHECK: VarDecl{{.*}} x 'int'
128 // CHECK: VarDecl{{.*}} x 'int'
129 // CHECK-NEXT: AlignedAttr{{.*}} Inherited
130 }
131
132 int __attribute__((cdecl)) TestOne(void), TestTwo(void);
133 // CHECK: FunctionDecl{{.*}}TestOne{{.*}}__attribute__((cdecl))
134 // CHECK: FunctionDecl{{.*}}TestTwo{{.*}}__attribute__((cdecl))
135
func()136 void func() {
137 auto Test = []() __attribute__((no_thread_safety_analysis)) {};
138 // CHECK: CXXMethodDecl{{.*}}operator() 'void () const'
139 // CHECK: NoThreadSafetyAnalysisAttr
140
141 // Because GNU's noreturn applies to the function type, and this lambda does
142 // not have a capture list, the call operator and the function pointer
143 // conversion should both be noreturn, but the method should not contain a
144 // NoReturnAttr because the attribute applied to the type.
145 auto Test2 = []() __attribute__((noreturn)) { while(1); };
146 // CHECK: CXXMethodDecl{{.*}}operator() 'void () __attribute__((noreturn)) const'
147 // CHECK-NOT: NoReturnAttr
148 // CHECK: CXXConversionDecl{{.*}}operator void (*)() __attribute__((noreturn))
149 }
150
151 namespace PR20930 {
152 struct S {
153 struct { int Test __attribute__((deprecated)); };
154 // CHECK: FieldDecl{{.*}}Test 'int'
155 // CHECK-NEXT: DeprecatedAttr
156 };
157
f()158 void f() {
159 S s;
160 s.Test = 1;
161 // CHECK: IndirectFieldDecl{{.*}}Test 'int'
162 // CHECK: DeprecatedAttr
163 }
164 }
165
166 struct __attribute__((objc_bridge_related(NSParagraphStyle,,))) TestBridgedRef;
167 // CHECK: CXXRecordDecl{{.*}} struct TestBridgedRef
168 // CHECK-NEXT: ObjCBridgeRelatedAttr{{.*}} NSParagraphStyle
169
170 void TestExternalSourceSymbolAttr1()
171 __attribute__((external_source_symbol(language="Swift", defined_in="module", generated_declaration)));
172 // CHECK: FunctionDecl{{.*}} TestExternalSourceSymbolAttr1
173 // CHECK-NEXT: ExternalSourceSymbolAttr{{.*}} "Swift" "module" GeneratedDeclaration
174
175 void TestExternalSourceSymbolAttr2()
176 __attribute__((external_source_symbol(defined_in="module", language="Swift")));
177 // CHECK: FunctionDecl{{.*}} TestExternalSourceSymbolAttr2
178 // CHECK-NEXT: ExternalSourceSymbolAttr{{.*}} "Swift" "module"{{$}}
179
180 void TestExternalSourceSymbolAttr3()
181 __attribute__((external_source_symbol(generated_declaration, language="Objective-C++", defined_in="module")));
182 // CHECK: FunctionDecl{{.*}} TestExternalSourceSymbolAttr3
183 // CHECK-NEXT: ExternalSourceSymbolAttr{{.*}} "Objective-C++" "module" GeneratedDeclaration
184
185 void TestExternalSourceSymbolAttr4()
186 __attribute__((external_source_symbol(defined_in="Some external file.cs", generated_declaration, language="C Sharp")));
187 // CHECK: FunctionDecl{{.*}} TestExternalSourceSymbolAttr4
188 // CHECK-NEXT: ExternalSourceSymbolAttr{{.*}} "C Sharp" "Some external file.cs" GeneratedDeclaration
189
190 void TestExternalSourceSymbolAttr5()
191 __attribute__((external_source_symbol(generated_declaration, defined_in="module", language="Swift")));
192 // CHECK: FunctionDecl{{.*}} TestExternalSourceSymbolAttr5
193 // CHECK-NEXT: ExternalSourceSymbolAttr{{.*}} "Swift" "module" GeneratedDeclaration
194
195 namespace TestNoEscape {
noescapeFunc(int * p0,int * p1)196 void noescapeFunc(int *p0, __attribute__((noescape)) int *p1) {}
197 // CHECK: `-FunctionDecl{{.*}} noescapeFunc 'void (int *, __attribute__((noescape)) int *)'
198 // CHECK-NEXT: ParmVarDecl
199 // CHECK-NEXT: ParmVarDecl
200 // CHECK-NEXT: NoEscapeAttr
201 }
202
203 namespace TestSuppress {
204 [[gsl::suppress("at-namespace")]];
205 // CHECK: NamespaceDecl{{.*}} TestSuppress
206 // CHECK-NEXT: EmptyDecl{{.*}}
207 // CHECK-NEXT: SuppressAttr{{.*}} at-namespace
208 [[gsl::suppress("on-decl")]]
209 void TestSuppressFunction();
210 // CHECK: FunctionDecl{{.*}} TestSuppressFunction
211 // CHECK-NEXT: SuppressAttr{{.*}} on-decl
212
f()213 void f() {
214 int *i;
215
216 [[gsl::suppress("on-stmt")]] {
217 // CHECK: AttributedStmt
218 // CHECK-NEXT: SuppressAttr{{.*}} on-stmt
219 // CHECK-NEXT: CompoundStmt
220 i = reinterpret_cast<int*>(7);
221 }
222 }
223 }
224
225 namespace TestLifetimeCategories {
226 class [[gsl::Owner(int)]] AOwner{};
227 // CHECK: CXXRecordDecl{{.*}} class AOwner
228 // CHECK: OwnerAttr {{.*}} int
229 class [[gsl::Pointer(int)]] APointer{};
230 // CHECK: CXXRecordDecl{{.*}} class APointer
231 // CHECK: PointerAttr {{.*}} int
232
233 class [[gsl::Pointer]] PointerWithoutArgument{};
234 // CHECK: CXXRecordDecl{{.*}} class PointerWithoutArgument
235 // CHECK: PointerAttr
236
237 class [[gsl::Owner]] OwnerWithoutArgument{};
238 // CHECK: CXXRecordDecl{{.*}} class OwnerWithoutArgument
239 // CHECK: OwnerAttr
240 } // namespace TestLifetimeCategories
241
242 // Verify the order of attributes in the Ast. It must reflect the order
243 // in the parsed source.
244 int mergeAttrTest() __attribute__((deprecated)) __attribute__((warn_unused_result));
245 int mergeAttrTest() __attribute__((annotate("test")));
246 int mergeAttrTest() __attribute__((unused,no_thread_safety_analysis));
247 // CHECK: FunctionDecl{{.*}} mergeAttrTest
248 // CHECK-NEXT: DeprecatedAttr
249 // CHECK-NEXT: WarnUnusedResultAttr
250
251 // CHECK: FunctionDecl{{.*}} mergeAttrTest
252 // CHECK-NEXT: DeprecatedAttr{{.*}} Inherited
253 // CHECK-NEXT: WarnUnusedResultAttr{{.*}} Inherited
254 // CHECK-NEXT: AnnotateAttr{{.*}}
255
256 // CHECK: FunctionDecl{{.*}} mergeAttrTest
257 // CHECK-NEXT: DeprecatedAttr{{.*}} Inherited
258 // CHECK-NEXT: WarnUnusedResultAttr{{.*}} Inherited
259 // CHECK-NEXT: AnnotateAttr{{.*}} Inherited
260 // CHECK-NEXT: UnusedAttr
261 // CHECK-NEXT: NoThreadSafetyAnalysisAttr
262