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 
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 
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 
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 
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 
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 {
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 
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