1 //===- unittest/Tooling/CleanupTest.cpp - Include insertion/deletion tests ===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8
9 #include "clang/Tooling/Inclusions/HeaderIncludes.h"
10 #include "../Tooling/ReplacementTest.h"
11 #include "../Tooling/RewriterTestContext.h"
12 #include "clang/Format/Format.h"
13 #include "clang/Tooling/Core/Replacement.h"
14
15 #include "gtest/gtest.h"
16
17 namespace clang {
18 namespace tooling {
19 namespace {
20
21 class HeaderIncludesTest : public ::testing::Test {
22 protected:
insert(llvm::StringRef Code,llvm::StringRef Header)23 std::string insert(llvm::StringRef Code, llvm::StringRef Header) {
24 HeaderIncludes Includes(FileName, Code, Style);
25 assert(Header.startswith("\"") || Header.startswith("<"));
26 auto R = Includes.insert(Header.trim("\"<>"), Header.startswith("<"));
27 if (!R)
28 return std::string(Code);
29 auto Result = applyAllReplacements(Code, Replacements(*R));
30 EXPECT_TRUE(static_cast<bool>(Result));
31 return *Result;
32 }
33
remove(llvm::StringRef Code,llvm::StringRef Header)34 std::string remove(llvm::StringRef Code, llvm::StringRef Header) {
35 HeaderIncludes Includes(FileName, Code, Style);
36 assert(Header.startswith("\"") || Header.startswith("<"));
37 auto Replaces = Includes.remove(Header.trim("\"<>"), Header.startswith("<"));
38 auto Result = applyAllReplacements(Code, Replaces);
39 EXPECT_TRUE(static_cast<bool>(Result));
40 return *Result;
41 }
42
43 std::string FileName = "fix.cpp";
44 IncludeStyle Style = format::getLLVMStyle().IncludeStyle;
45 };
46
TEST_F(HeaderIncludesTest,NoExistingIncludeWithoutDefine)47 TEST_F(HeaderIncludesTest, NoExistingIncludeWithoutDefine) {
48 std::string Code = "int main() {}";
49 std::string Expected = "#include \"a.h\"\n"
50 "int main() {}";
51 EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
52 }
53
TEST_F(HeaderIncludesTest,RepeatedIncludes)54 TEST_F(HeaderIncludesTest, RepeatedIncludes) {
55 std::string Code;
56 for (int i = 0; i < 100; ++i) {
57 Code += "#include \"a.h\"\n";
58 }
59 std::string Expected = Code + "#include \"a2.h\"\n";
60 EXPECT_EQ(Expected, insert(Code, "\"a2.h\""));
61 }
62
TEST_F(HeaderIncludesTest,NoExistingIncludeWithDefine)63 TEST_F(HeaderIncludesTest, NoExistingIncludeWithDefine) {
64 std::string Code = "#ifndef A_H\n"
65 "#define A_H\n"
66 "class A {};\n"
67 "#define MMM 123\n"
68 "#endif";
69 std::string Expected = "#ifndef A_H\n"
70 "#define A_H\n"
71 "#include \"b.h\"\n"
72 "class A {};\n"
73 "#define MMM 123\n"
74 "#endif";
75
76 EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
77 }
78
TEST_F(HeaderIncludesTest,InsertBeforeCategoryWithLowerPriority)79 TEST_F(HeaderIncludesTest, InsertBeforeCategoryWithLowerPriority) {
80 std::string Code = "#ifndef A_H\n"
81 "#define A_H\n"
82 "\n"
83 "\n"
84 "\n"
85 "#include <vector>\n"
86 "class A {};\n"
87 "#define MMM 123\n"
88 "#endif";
89 std::string Expected = "#ifndef A_H\n"
90 "#define A_H\n"
91 "\n"
92 "\n"
93 "\n"
94 "#include \"a.h\"\n"
95 "#include <vector>\n"
96 "class A {};\n"
97 "#define MMM 123\n"
98 "#endif";
99
100 EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
101 }
102
TEST_F(HeaderIncludesTest,InsertAfterMainHeader)103 TEST_F(HeaderIncludesTest, InsertAfterMainHeader) {
104 std::string Code = "#include \"fix.h\"\n"
105 "\n"
106 "int main() {}";
107 std::string Expected = "#include \"fix.h\"\n"
108 "#include <a>\n"
109 "\n"
110 "int main() {}";
111 Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
112 .IncludeStyle;
113 EXPECT_EQ(Expected, insert(Code, "<a>"));
114
115 FileName = "fix.cu.cpp";
116 EXPECT_EQ(Expected, insert(Code, "<a>"));
117
118 FileName = "fix_test.cu.cpp";
119 EXPECT_EQ(Expected, insert(Code, "<a>"));
120
121 FileName = "bar.cpp";
122 EXPECT_NE(Expected, insert(Code, "<a>")) << "Not main header";
123 }
124
TEST_F(HeaderIncludesTest,InsertBeforeSystemHeaderLLVM)125 TEST_F(HeaderIncludesTest, InsertBeforeSystemHeaderLLVM) {
126 std::string Code = "#include <memory>\n"
127 "\n"
128 "int main() {}";
129 std::string Expected = "#include \"z.h\"\n"
130 "#include <memory>\n"
131 "\n"
132 "int main() {}";
133 EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
134 }
135
TEST_F(HeaderIncludesTest,InsertAfterSystemHeaderGoogle)136 TEST_F(HeaderIncludesTest, InsertAfterSystemHeaderGoogle) {
137 std::string Code = "#include <memory>\n"
138 "\n"
139 "int main() {}";
140 std::string Expected = "#include <memory>\n"
141 "#include \"z.h\"\n"
142 "\n"
143 "int main() {}";
144 Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
145 .IncludeStyle;
146 EXPECT_EQ(Expected, insert(Code, "\"z.h\""));
147 }
148
TEST_F(HeaderIncludesTest,InsertOneIncludeLLVMStyle)149 TEST_F(HeaderIncludesTest, InsertOneIncludeLLVMStyle) {
150 std::string Code = "#include \"x/fix.h\"\n"
151 "#include \"a.h\"\n"
152 "#include \"b.h\"\n"
153 "#include \"clang/Format/Format.h\"\n"
154 "#include <memory>\n";
155 std::string Expected = "#include \"x/fix.h\"\n"
156 "#include \"a.h\"\n"
157 "#include \"b.h\"\n"
158 "#include \"clang/Format/Format.h\"\n"
159 "#include \"llvm/x/y.h\"\n"
160 "#include <memory>\n";
161 EXPECT_EQ(Expected, insert(Code, "\"llvm/x/y.h\""));
162 }
163
TEST_F(HeaderIncludesTest,InsertIntoBlockSorted)164 TEST_F(HeaderIncludesTest, InsertIntoBlockSorted) {
165 std::string Code = "#include \"x/fix.h\"\n"
166 "#include \"a.h\"\n"
167 "#include \"c.h\"\n"
168 "#include <memory>\n";
169 std::string Expected = "#include \"x/fix.h\"\n"
170 "#include \"a.h\"\n"
171 "#include \"b.h\"\n"
172 "#include \"c.h\"\n"
173 "#include <memory>\n";
174 EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
175 }
176
TEST_F(HeaderIncludesTest,InsertIntoFirstBlockOfSameKind)177 TEST_F(HeaderIncludesTest, InsertIntoFirstBlockOfSameKind) {
178 std::string Code = "#include \"x/fix.h\"\n"
179 "#include \"c.h\"\n"
180 "#include \"e.h\"\n"
181 "#include \"f.h\"\n"
182 "#include <memory>\n"
183 "#include <vector>\n"
184 "#include \"m.h\"\n"
185 "#include \"n.h\"\n";
186 std::string Expected = "#include \"x/fix.h\"\n"
187 "#include \"c.h\"\n"
188 "#include \"d.h\"\n"
189 "#include \"e.h\"\n"
190 "#include \"f.h\"\n"
191 "#include <memory>\n"
192 "#include <vector>\n"
193 "#include \"m.h\"\n"
194 "#include \"n.h\"\n";
195 EXPECT_EQ(Expected, insert(Code, "\"d.h\""));
196 }
197
TEST_F(HeaderIncludesTest,InsertIntoSystemBlockSorted)198 TEST_F(HeaderIncludesTest, InsertIntoSystemBlockSorted) {
199 std::string Code = "#include \"x/fix.h\"\n"
200 "#include \"a.h\"\n"
201 "#include \"c.h\"\n"
202 "#include <a>\n"
203 "#include <z>\n";
204 std::string Expected = "#include \"x/fix.h\"\n"
205 "#include \"a.h\"\n"
206 "#include \"c.h\"\n"
207 "#include <a>\n"
208 "#include <vector>\n"
209 "#include <z>\n";
210 EXPECT_EQ(Expected, insert(Code, "<vector>"));
211 }
212
TEST_F(HeaderIncludesTest,InsertNewSystemIncludeGoogleStyle)213 TEST_F(HeaderIncludesTest, InsertNewSystemIncludeGoogleStyle) {
214 std::string Code = "#include \"x/fix.h\"\n"
215 "\n"
216 "#include \"y/a.h\"\n"
217 "#include \"z/b.h\"\n";
218 // FIXME: inserting after the empty line following the main header might be
219 // preferred.
220 std::string Expected = "#include \"x/fix.h\"\n"
221 "#include <vector>\n"
222 "\n"
223 "#include \"y/a.h\"\n"
224 "#include \"z/b.h\"\n";
225 Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
226 .IncludeStyle;
227 EXPECT_EQ(Expected, insert(Code, "<vector>"));
228 }
229
TEST_F(HeaderIncludesTest,NotConfusedByDefine)230 TEST_F(HeaderIncludesTest, NotConfusedByDefine) {
231 std::string Code = "void f() {}\n"
232 "#define A \\\n"
233 " int i;";
234 std::string Expected = "#include <vector>\n"
235 "void f() {}\n"
236 "#define A \\\n"
237 " int i;";
238 EXPECT_EQ(Expected, insert(Code, "<vector>"));
239 }
240
TEST_F(HeaderIncludesTest,SkippedTopComment)241 TEST_F(HeaderIncludesTest, SkippedTopComment) {
242 std::string Code = "// comment\n"
243 "\n"
244 " // comment\n";
245 std::string Expected = "// comment\n"
246 "\n"
247 " // comment\n"
248 "#include <vector>\n";
249 EXPECT_EQ(Expected, insert(Code, "<vector>"));
250 }
251
TEST_F(HeaderIncludesTest,SkippedMixedComments)252 TEST_F(HeaderIncludesTest, SkippedMixedComments) {
253 std::string Code = "// comment\n"
254 "// comment \\\n"
255 " comment continued\n"
256 "/*\n"
257 "* comment\n"
258 "*/\n";
259 std::string Expected = "// comment\n"
260 "// comment \\\n"
261 " comment continued\n"
262 "/*\n"
263 "* comment\n"
264 "*/\n"
265 "#include <vector>\n";
266 EXPECT_EQ(Expected, insert(Code, "<vector>"));
267 }
268
TEST_F(HeaderIncludesTest,MultipleBlockCommentsInOneLine)269 TEST_F(HeaderIncludesTest, MultipleBlockCommentsInOneLine) {
270 std::string Code = "/*\n"
271 "* comment\n"
272 "*/ /* comment\n"
273 "*/\n"
274 "\n\n"
275 "/* c1 */ /*c2 */\n";
276 std::string Expected = "/*\n"
277 "* comment\n"
278 "*/ /* comment\n"
279 "*/\n"
280 "\n\n"
281 "/* c1 */ /*c2 */\n"
282 "#include <vector>\n";
283 EXPECT_EQ(Expected, insert(Code, "<vector>"));
284 }
285
TEST_F(HeaderIncludesTest,CodeAfterComments)286 TEST_F(HeaderIncludesTest, CodeAfterComments) {
287 std::string Code = "/*\n"
288 "* comment\n"
289 "*/ /* comment\n"
290 "*/\n"
291 "\n\n"
292 "/* c1 */ /*c2 */\n"
293 "\n"
294 "int x;\n";
295 std::string Expected = "/*\n"
296 "* comment\n"
297 "*/ /* comment\n"
298 "*/\n"
299 "\n\n"
300 "/* c1 */ /*c2 */\n"
301 "\n"
302 "#include <vector>\n"
303 "int x;\n";
304 EXPECT_EQ(Expected, insert(Code, "<vector>"));
305 }
306
TEST_F(HeaderIncludesTest,FakeHeaderGuardIfDef)307 TEST_F(HeaderIncludesTest, FakeHeaderGuardIfDef) {
308 std::string Code = "// comment \n"
309 "#ifdef X\n"
310 "#define X\n";
311 std::string Expected = "// comment \n"
312 "#include <vector>\n"
313 "#ifdef X\n"
314 "#define X\n";
315 EXPECT_EQ(Expected, insert(Code, "<vector>"));
316 }
317
TEST_F(HeaderIncludesTest,RealHeaderGuardAfterComments)318 TEST_F(HeaderIncludesTest, RealHeaderGuardAfterComments) {
319 std::string Code = "// comment \n"
320 "#ifndef X\n"
321 "#define X\n"
322 "int x;\n"
323 "#define Y 1\n";
324 std::string Expected = "// comment \n"
325 "#ifndef X\n"
326 "#define X\n"
327 "#include <vector>\n"
328 "int x;\n"
329 "#define Y 1\n";
330 EXPECT_EQ(Expected, insert(Code, "<vector>"));
331 }
332
TEST_F(HeaderIncludesTest,PragmaOnce)333 TEST_F(HeaderIncludesTest, PragmaOnce) {
334 std::string Code = "// comment \n"
335 "#pragma once\n"
336 "int x;\n";
337 std::string Expected = "// comment \n"
338 "#pragma once\n"
339 "#include <vector>\n"
340 "int x;\n";
341 EXPECT_EQ(Expected, insert(Code, "<vector>"));
342 }
343
TEST_F(HeaderIncludesTest,IfNDefWithNoDefine)344 TEST_F(HeaderIncludesTest, IfNDefWithNoDefine) {
345 std::string Code = "// comment \n"
346 "#ifndef X\n"
347 "int x;\n"
348 "#define Y 1\n";
349 std::string Expected = "// comment \n"
350 "#include <vector>\n"
351 "#ifndef X\n"
352 "int x;\n"
353 "#define Y 1\n";
354 EXPECT_EQ(Expected, insert(Code, "<vector>"));
355 }
356
TEST_F(HeaderIncludesTest,FakeHeaderGuard)357 TEST_F(HeaderIncludesTest, FakeHeaderGuard) {
358 std::string Code = "// comment \n"
359 "#ifndef X\n"
360 "#define 1\n";
361 std::string Expected = "// comment \n"
362 "#include <vector>\n"
363 "#ifndef X\n"
364 "#define 1\n";
365 EXPECT_EQ(Expected, insert(Code, "<vector>"));
366 }
367
TEST_F(HeaderIncludesTest,FakeHeaderGuardIfnDef)368 TEST_F(HeaderIncludesTest, FakeHeaderGuardIfnDef) {
369 std::string Code = "#ifndef A_H\n"
370 "#define A_H 1\n"
371 "#endif";
372 std::string Expected = "#include \"b.h\"\n"
373 "#ifndef A_H\n"
374 "#define A_H 1\n"
375 "#endif";
376
377 EXPECT_EQ(Expected, insert(Code, "\"b.h\""));
378 }
379
TEST_F(HeaderIncludesTest,HeaderGuardWithComment)380 TEST_F(HeaderIncludesTest, HeaderGuardWithComment) {
381 std::string Code = "// comment \n"
382 "#ifndef X // comment\n"
383 "// comment\n"
384 "/* comment\n"
385 "*/\n"
386 "/* comment */ #define X\n"
387 "int x;\n"
388 "#define Y 1\n";
389 std::string Expected = "// comment \n"
390 "#ifndef X // comment\n"
391 "// comment\n"
392 "/* comment\n"
393 "*/\n"
394 "/* comment */ #define X\n"
395 "#include <vector>\n"
396 "int x;\n"
397 "#define Y 1\n";
398 EXPECT_EQ(Expected, insert(Code, "<vector>"));
399 }
400
TEST_F(HeaderIncludesTest,EmptyCode)401 TEST_F(HeaderIncludesTest, EmptyCode) {
402 std::string Code = "";
403 std::string Expected = "#include <vector>\n";
404 EXPECT_EQ(Expected, insert(Code, "<vector>"));
405 }
406
TEST_F(HeaderIncludesTest,NoNewLineAtTheEndOfCode)407 TEST_F(HeaderIncludesTest, NoNewLineAtTheEndOfCode) {
408 std::string Code = "#include <map>";
409 std::string Expected = "#include <map>\n#include <vector>\n";
410 EXPECT_EQ(Expected, insert(Code, "<vector>"));
411 }
412
TEST_F(HeaderIncludesTest,SkipExistingHeaders)413 TEST_F(HeaderIncludesTest, SkipExistingHeaders) {
414 std::string Code = "#include \"a.h\"\n"
415 "#include <vector>\n";
416 std::string Expected = "#include \"a.h\"\n"
417 "#include <vector>\n";
418 EXPECT_EQ(Expected, insert(Code, "<vector>"));
419 EXPECT_EQ(Expected, insert(Code, "\"a.h\""));
420 }
421
TEST_F(HeaderIncludesTest,AddIncludesWithDifferentForms)422 TEST_F(HeaderIncludesTest, AddIncludesWithDifferentForms) {
423 std::string Code = "#include <vector>\n";
424 // FIXME: this might not be the best behavior.
425 std::string Expected = "#include \"vector\"\n"
426 "#include <vector>\n";
427 EXPECT_EQ(Expected, insert(Code, "\"vector\""));
428 }
429
TEST_F(HeaderIncludesTest,NoInsertionAfterCode)430 TEST_F(HeaderIncludesTest, NoInsertionAfterCode) {
431 std::string Code = "#include \"a.h\"\n"
432 "void f() {}\n"
433 "#include \"b.h\"\n";
434 std::string Expected = "#include \"a.h\"\n"
435 "#include \"c.h\"\n"
436 "void f() {}\n"
437 "#include \"b.h\"\n";
438 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
439 }
440
TEST_F(HeaderIncludesTest,NoInsertionInStringLiteral)441 TEST_F(HeaderIncludesTest, NoInsertionInStringLiteral) {
442 std::string Code = "#include \"a.h\"\n"
443 "const char[] = R\"(\n"
444 "#include \"b.h\"\n"
445 ")\";\n";
446 std::string Expected = "#include \"a.h\"\n"
447 "#include \"c.h\"\n"
448 "const char[] = R\"(\n"
449 "#include \"b.h\"\n"
450 ")\";\n";
451 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
452 }
453
TEST_F(HeaderIncludesTest,NoInsertionAfterOtherDirective)454 TEST_F(HeaderIncludesTest, NoInsertionAfterOtherDirective) {
455 std::string Code = "#include \"a.h\"\n"
456 "#ifdef X\n"
457 "#include \"b.h\"\n"
458 "#endif\n";
459 std::string Expected = "#include \"a.h\"\n"
460 "#include \"c.h\"\n"
461 "#ifdef X\n"
462 "#include \"b.h\"\n"
463 "#endif\n";
464 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
465 }
466
TEST_F(HeaderIncludesTest,CanInsertAfterLongSystemInclude)467 TEST_F(HeaderIncludesTest, CanInsertAfterLongSystemInclude) {
468 std::string Code = "#include \"a.h\"\n"
469 "// comment\n\n"
470 "#include <a/b/c/d/e.h>\n";
471 std::string Expected = "#include \"a.h\"\n"
472 "// comment\n\n"
473 "#include <a/b/c/d/e.h>\n"
474 "#include <x.h>\n";
475 EXPECT_EQ(Expected, insert(Code, "<x.h>"));
476 }
477
TEST_F(HeaderIncludesTest,CanInsertAfterComment)478 TEST_F(HeaderIncludesTest, CanInsertAfterComment) {
479 std::string Code = "#include \"a.h\"\n"
480 "// Comment\n"
481 "\n"
482 "/* Comment */\n"
483 "// Comment\n"
484 "\n"
485 "#include \"b.h\"\n";
486 std::string Expected = "#include \"a.h\"\n"
487 "// Comment\n"
488 "\n"
489 "/* Comment */\n"
490 "// Comment\n"
491 "\n"
492 "#include \"b.h\"\n"
493 "#include \"c.h\"\n";
494 EXPECT_EQ(Expected, insert(Code, "\"c.h\""));
495 }
496
TEST_F(HeaderIncludesTest,LongCommentsInTheBeginningOfFile)497 TEST_F(HeaderIncludesTest, LongCommentsInTheBeginningOfFile) {
498 std::string Code = "// Loooooooooooooooooooooooooong comment\n"
499 "// Loooooooooooooooooooooooooong comment\n"
500 "// Loooooooooooooooooooooooooong comment\n"
501 "#include <string>\n"
502 "#include <vector>\n"
503 "\n"
504 "#include \"a.h\"\n"
505 "#include \"b.h\"\n";
506 std::string Expected = "// Loooooooooooooooooooooooooong comment\n"
507 "// Loooooooooooooooooooooooooong comment\n"
508 "// Loooooooooooooooooooooooooong comment\n"
509 "#include <string>\n"
510 "#include <vector>\n"
511 "\n"
512 "#include \"a.h\"\n"
513 "#include \"b.h\"\n"
514 "#include \"third.h\"\n";
515 Style = format::getGoogleStyle(format::FormatStyle::LanguageKind::LK_Cpp)
516 .IncludeStyle;
517 EXPECT_EQ(Expected, insert(Code, "\"third.h\""));
518 }
519
TEST_F(HeaderIncludesTest,SimpleDeleteInclude)520 TEST_F(HeaderIncludesTest, SimpleDeleteInclude) {
521 std::string Code = "#include \"abc.h\"\n"
522 "#include \"xyz.h\" // comment\n"
523 "int x;\n";
524 std::string Expected = "#include \"abc.h\"\n"
525 "int x;\n";
526 EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
527 }
528
TEST_F(HeaderIncludesTest,DeleteQuotedOnly)529 TEST_F(HeaderIncludesTest, DeleteQuotedOnly) {
530 std::string Code = "#include \"abc.h\"\n"
531 "#include <abc.h>\n"
532 "int x;\n";
533 std::string Expected = "#include <abc.h>\n"
534 "int x;\n";
535 EXPECT_EQ(Expected, remove(Code, "\"abc.h\""));
536 }
537
TEST_F(HeaderIncludesTest,DeleteAllCode)538 TEST_F(HeaderIncludesTest, DeleteAllCode) {
539 std::string Code = "#include \"xyz.h\"\n";
540 std::string Expected = "";
541 EXPECT_EQ(Expected, remove(Code, "\"xyz.h\""));
542 }
543
TEST_F(HeaderIncludesTest,DeleteOnlyIncludesWithSameQuote)544 TEST_F(HeaderIncludesTest, DeleteOnlyIncludesWithSameQuote) {
545 std::string Code = "#include \"xyz.h\"\n"
546 "#include \"xyz\"\n"
547 "#include <xyz.h>\n";
548 std::string Expected = "#include \"xyz.h\"\n"
549 "#include \"xyz\"\n";
550 EXPECT_EQ(Expected, remove(Code, "<xyz.h>"));
551 }
552
TEST_F(HeaderIncludesTest,CanDeleteAfterCode)553 TEST_F(HeaderIncludesTest, CanDeleteAfterCode) {
554 std::string Code = "#include \"a.h\"\n"
555 "void f() {}\n"
556 "#include \"b.h\"\n";
557 std::string Expected = "#include \"a.h\"\n"
558 "void f() {}\n";
559 EXPECT_EQ(Expected, remove(Code, "\"b.h\""));
560 }
561
562 } // namespace
563 } // namespace tooling
564 } // namespace clang
565