1 | //===- DefinitionBlockSeparatorTest.cpp - Formatting unit 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 "FormatTestUtils.h" |
10 | #include "clang/Format/Format.h" |
11 | |
12 | #include "llvm/Support/Debug.h" |
13 | #include "gtest/gtest.h" |
14 | |
15 | #define DEBUG_TYPE "definition-block-separator-test" |
16 | |
17 | namespace clang { |
18 | namespace format { |
19 | namespace { |
20 | |
21 | class DefinitionBlockSeparatorTest : public testing::Test { |
22 | protected: |
23 | static std::string |
24 | separateDefinitionBlocks(StringRef Code, |
25 | const std::vector<tooling::Range> &Ranges, |
26 | const FormatStyle &Style = getLLVMStyle()) { |
27 | LLVM_DEBUG(llvm::errs() << "---\n" ); |
28 | LLVM_DEBUG(llvm::errs() << Code << "\n\n" ); |
29 | tooling::Replacements Replaces = reformat(Style, Code, Ranges, FileName: "<stdin>" ); |
30 | auto Result = applyAllReplacements(Code, Replaces); |
31 | EXPECT_TRUE(static_cast<bool>(Result)); |
32 | LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n" ); |
33 | return *Result; |
34 | } |
35 | |
36 | static std::string |
37 | separateDefinitionBlocks(StringRef Code, |
38 | const FormatStyle &Style = getLLVMStyle()) { |
39 | return separateDefinitionBlocks( |
40 | Code, |
41 | /*Ranges=*/{1, tooling::Range(0, Code.size())}, Style); |
42 | } |
43 | |
44 | static void _verifyFormat(const char *File, int Line, StringRef Code, |
45 | const FormatStyle &Style = getLLVMStyle(), |
46 | StringRef ExpectedCode = "" , bool Inverse = true) { |
47 | testing::ScopedTrace t(File, Line, testing::Message() << Code.str()); |
48 | bool HasOriginalCode = true; |
49 | if (ExpectedCode == "" ) { |
50 | ExpectedCode = Code; |
51 | HasOriginalCode = false; |
52 | } |
53 | |
54 | EXPECT_EQ(ExpectedCode, separateDefinitionBlocks(ExpectedCode, Style)) |
55 | << "Expected code is not stable" ; |
56 | if (Inverse) { |
57 | FormatStyle InverseStyle = Style; |
58 | if (Style.SeparateDefinitionBlocks == FormatStyle::SDS_Always) |
59 | InverseStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Never; |
60 | else |
61 | InverseStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
62 | EXPECT_NE(ExpectedCode, |
63 | separateDefinitionBlocks(ExpectedCode, InverseStyle)) |
64 | << "Inverse formatting makes no difference" ; |
65 | } |
66 | std::string CodeToFormat = |
67 | HasOriginalCode ? Code.str() : removeEmptyLines(Code); |
68 | std::string Result = separateDefinitionBlocks(Code: CodeToFormat, Style); |
69 | EXPECT_EQ(ExpectedCode, Result) << "Test failed. Formatted:\n" << Result; |
70 | } |
71 | |
72 | static std::string removeEmptyLines(StringRef Code) { |
73 | std::string Result = "" ; |
74 | for (auto Char : Code.str()) { |
75 | if (Result.size()) { |
76 | auto LastChar = Result.back(); |
77 | if ((Char == '\n' && LastChar == '\n') || |
78 | (Char == '\r' && (LastChar == '\r' || LastChar == '\n'))) { |
79 | continue; |
80 | } |
81 | } |
82 | Result.push_back(c: Char); |
83 | } |
84 | return Result; |
85 | } |
86 | }; |
87 | |
88 | #define verifyFormat(...) _verifyFormat(__FILE__, __LINE__, __VA_ARGS__) |
89 | |
90 | TEST_F(DefinitionBlockSeparatorTest, Basic) { |
91 | FormatStyle Style = getLLVMStyle(); |
92 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
93 | verifyFormat("int foo(int i, int j) {\n" |
94 | " int r = i + j;\n" |
95 | " return r;\n" |
96 | "}\n" |
97 | "\n" |
98 | "int bar(int j, int k) {\n" |
99 | " int r = j + k;\n" |
100 | " return r;\n" |
101 | "}" , |
102 | Style); |
103 | |
104 | verifyFormat("struct foo {\n" |
105 | " int i, j;\n" |
106 | "};\n" |
107 | "\n" |
108 | "struct bar {\n" |
109 | " int j, k;\n" |
110 | "};" , |
111 | Style); |
112 | |
113 | verifyFormat("union foo {\n" |
114 | " int i, j;\n" |
115 | "};\n" |
116 | "\n" |
117 | "union bar {\n" |
118 | " int j, k;\n" |
119 | "};" , |
120 | Style); |
121 | |
122 | verifyFormat("class foo {\n" |
123 | " int i, j;\n" |
124 | "};\n" |
125 | "\n" |
126 | "class bar {\n" |
127 | " int j, k;\n" |
128 | "};" , |
129 | Style); |
130 | |
131 | verifyFormat("namespace foo {\n" |
132 | "int i, j;\n" |
133 | "}\n" |
134 | "\n" |
135 | "namespace bar {\n" |
136 | "int j, k;\n" |
137 | "}" , |
138 | Style); |
139 | |
140 | verifyFormat("enum Foo { FOO, BAR };\n" |
141 | "\n" |
142 | "enum Bar { FOOBAR, BARFOO };" , |
143 | Style); |
144 | |
145 | FormatStyle BreakAfterReturnTypeStyle = Style; |
146 | BreakAfterReturnTypeStyle.BreakAfterReturnType = FormatStyle::RTBS_All; |
147 | // Test uppercased long typename |
148 | verifyFormat("class Foo {\n" |
149 | " void\n" |
150 | " Bar(int t, int p) {\n" |
151 | " int r = t + p;\n" |
152 | " return r;\n" |
153 | " }\n" |
154 | "\n" |
155 | " HRESULT\n" |
156 | " Foobar(int t, int p) {\n" |
157 | " int r = t * p;\n" |
158 | " return r;\n" |
159 | " }\n" |
160 | "}" , |
161 | BreakAfterReturnTypeStyle); |
162 | } |
163 | |
164 | TEST_F(DefinitionBlockSeparatorTest, FormatConflict) { |
165 | FormatStyle Style = getLLVMStyle(); |
166 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
167 | StringRef Code = "class Test {\n" |
168 | "public:\n" |
169 | " static void foo() {\n" |
170 | " int t;\n" |
171 | " return 1;\n" |
172 | " }\n" |
173 | "};" ; |
174 | std::vector<tooling::Range> Ranges = {1, tooling::Range(0, Code.size())}; |
175 | EXPECT_EQ(reformat(Style, Code, Ranges, "<stdin>" ).size(), 0u); |
176 | } |
177 | |
178 | TEST_F(DefinitionBlockSeparatorTest, CommentBlock) { |
179 | FormatStyle Style = getLLVMStyle(); |
180 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
181 | std::string Prefix = "enum Foo { FOO, BAR };\n" |
182 | "\n" |
183 | "/*\n" |
184 | "test1\n" |
185 | "test2\n" |
186 | "*/\n" |
187 | "int foo(int i, int j) {\n" |
188 | " int r = i + j;\n" |
189 | " return r;\n" |
190 | "}\n" ; |
191 | std::string Suffix = "enum Bar { FOOBAR, BARFOO };\n" |
192 | "\n" |
193 | "/* Comment block in one line*/\n" |
194 | "int bar3(int j, int k) {\n" |
195 | " // A comment\n" |
196 | " int r = j % k;\n" |
197 | " return r;\n" |
198 | "}\n" ; |
199 | std::string = "/*\n" |
200 | "int bar2(int j, int k) {\n" |
201 | " int r = j / k;\n" |
202 | " return r;\n" |
203 | "}\n" |
204 | "*/\n" ; |
205 | verifyFormat(removeEmptyLines(Prefix) + "\n" + CommentedCode + "\n" + |
206 | removeEmptyLines(Suffix), |
207 | Style, Prefix + "\n" + CommentedCode + "\n" + Suffix); |
208 | verifyFormat(removeEmptyLines(Prefix) + "\n" + CommentedCode + |
209 | removeEmptyLines(Suffix), |
210 | Style, Prefix + "\n" + CommentedCode + Suffix); |
211 | } |
212 | |
213 | TEST_F(DefinitionBlockSeparatorTest, UntouchBlockStartStyle) { |
214 | // Returns a std::pair of two strings, with the first one for passing into |
215 | // Always test and the second one be the expected result of the first string. |
216 | auto MakeUntouchTest = [&](std::string , std::string BlockChanger, |
217 | std::string , bool BlockEndNewLine) { |
218 | std::string CodePart1 = "enum Foo { FOO, BAR };\n" |
219 | "\n" |
220 | "/*\n" |
221 | "test1\n" |
222 | "test2\n" |
223 | "*/\n" |
224 | "int foo(int i, int j) {\n" |
225 | " int r = i + j;\n" |
226 | " return r;\n" |
227 | "}\n" ; |
228 | std::string CodePart2 = "/* Comment block in one line*/\n" |
229 | "enum Bar { FOOBAR, BARFOO };\n" |
230 | "\n" |
231 | "int bar3(int j, int k) {\n" |
232 | " // A comment\n" |
233 | " int r = j % k;\n" |
234 | " return r;\n" |
235 | "}\n" ; |
236 | std::string CodePart3 = "int bar2(int j, int k) {\n" |
237 | " int r = j / k;\n" |
238 | " return r;\n" |
239 | "}\n" ; |
240 | std::string ConcatAll = BlockHeader + CodePart1 + BlockChanger + CodePart2 + |
241 | BlockFooter + (BlockEndNewLine ? "\n" : "" ) + |
242 | CodePart3; |
243 | return std::make_pair(x: BlockHeader + removeEmptyLines(Code: CodePart1) + |
244 | BlockChanger + removeEmptyLines(Code: CodePart2) + |
245 | BlockFooter + removeEmptyLines(Code: CodePart3), |
246 | y&: ConcatAll); |
247 | }; |
248 | |
249 | FormatStyle AlwaysStyle = getLLVMStyle(); |
250 | AlwaysStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
251 | |
252 | FormatStyle NeverStyle = getLLVMStyle(); |
253 | NeverStyle.SeparateDefinitionBlocks = FormatStyle::SDS_Never; |
254 | |
255 | auto TestKit = MakeUntouchTest("/* FOOBAR */\n" |
256 | "#ifdef FOO\n\n" , |
257 | "\n#elifndef BAR\n\n" , "\n#endif\n\n" , false); |
258 | verifyFormat(TestKit.first, AlwaysStyle, TestKit.second); |
259 | verifyFormat(TestKit.second, NeverStyle, removeEmptyLines(TestKit.second)); |
260 | |
261 | TestKit = MakeUntouchTest("/* FOOBAR */\n" |
262 | "#ifdef FOO\n" , |
263 | "#elifndef BAR\n" , "#endif\n" , false); |
264 | verifyFormat(TestKit.first, AlwaysStyle, TestKit.second); |
265 | verifyFormat(TestKit.second, NeverStyle, removeEmptyLines(TestKit.second)); |
266 | |
267 | TestKit = MakeUntouchTest("namespace Ns {\n\n" , |
268 | "\n} // namespace Ns\n\n" |
269 | "namespace {\n\n" , |
270 | "\n} // namespace\n" , true); |
271 | verifyFormat(TestKit.first, AlwaysStyle, TestKit.second); |
272 | verifyFormat(TestKit.second, NeverStyle, removeEmptyLines(TestKit.second)); |
273 | |
274 | TestKit = MakeUntouchTest("namespace Ns {\n" , |
275 | "} // namespace Ns\n\n" |
276 | "namespace {\n" , |
277 | "} // namespace\n" , true); |
278 | verifyFormat(TestKit.first, AlwaysStyle, TestKit.second); |
279 | verifyFormat(TestKit.second, NeverStyle, removeEmptyLines(TestKit.second)); |
280 | } |
281 | |
282 | TEST_F(DefinitionBlockSeparatorTest, Always) { |
283 | FormatStyle Style = getLLVMStyle(); |
284 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
285 | |
286 | verifyFormat("// clang-format off\n" |
287 | "template<class T>\n" |
288 | "concept C = not A<S<T>>;\n" |
289 | "// clang-format on\n" |
290 | "\n" |
291 | "struct E {};" , |
292 | Style); |
293 | |
294 | std::string Prefix = "namespace {\n" ; |
295 | std::string Infix = "\n" |
296 | "// Enum test1\n" |
297 | "// Enum test2\n" |
298 | "enum Foo { FOO, BAR };\n" |
299 | "\n" |
300 | "/*\n" |
301 | "test1\n" |
302 | "test2\n" |
303 | "*/\n" |
304 | "/*const*/ int foo(int i, int j) {\n" |
305 | " int r = i + j;\n" |
306 | " return r;\n" |
307 | "}\n" |
308 | "\n" |
309 | "// Foobar\n" |
310 | "int i, j, k;\n" |
311 | "\n" |
312 | "// Comment for function\n" |
313 | "// Comment line 2\n" |
314 | "// Comment line 3\n" |
315 | "int bar(int j, int k) {\n" |
316 | " {\n" |
317 | " int r = j * k;\n" |
318 | " return r;\n" |
319 | " }\n" |
320 | "}\n" |
321 | "\n" |
322 | "int bar2(int j, int k) {\n" |
323 | " int r = j / k;\n" |
324 | " return r;\n" |
325 | "}\n" |
326 | "\n" |
327 | "/* Comment block in one line*/\n" |
328 | "enum Bar { FOOBAR, BARFOO };\n" |
329 | "\n" |
330 | "int bar3(int j, int k, const enum Bar b) {\n" |
331 | " // A comment\n" |
332 | " int r = j % k;\n" |
333 | " if (struct S = getS()) {\n" |
334 | " // if condition\n" |
335 | " }\n" |
336 | " return r;\n" |
337 | "}\n" ; |
338 | std::string Postfix = "\n" |
339 | "} // namespace\n" |
340 | "\n" |
341 | "namespace T {\n" |
342 | "int i, j, k;\n" |
343 | "} // namespace T" ; |
344 | verifyFormat(Prefix + removeEmptyLines(Infix) + removeEmptyLines(Postfix), |
345 | Style, Prefix + Infix + Postfix); |
346 | } |
347 | |
348 | TEST_F(DefinitionBlockSeparatorTest, Never) { |
349 | FormatStyle Style = getLLVMStyle(); |
350 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Never; |
351 | std::string Prefix = "namespace {\n" ; |
352 | std::string Postfix = "// Enum test1\n" |
353 | "// Enum test2\n" |
354 | "enum Foo { FOO, BAR };\n" |
355 | "\n" |
356 | "/*\n" |
357 | "test1\n" |
358 | "test2\n" |
359 | "*/\n" |
360 | "/*const*/ int foo(int i, int j) {\n" |
361 | " int r = i + j;\n" |
362 | " return r;\n" |
363 | "}\n" |
364 | "\n" |
365 | "// Foobar\n" |
366 | "int i, j, k;\n" |
367 | "\n" |
368 | "// Comment for function\n" |
369 | "// Comment line 2\n" |
370 | "// Comment line 3\n" |
371 | "int bar(int j, int k) {\n" |
372 | " {\n" |
373 | " int r = j * k;\n" |
374 | " return r;\n" |
375 | " }\n" |
376 | "}\n" |
377 | "\n" |
378 | "int bar2(int j, int k) {\n" |
379 | " int r = j / k;\n" |
380 | " return r;\n" |
381 | "}\n" |
382 | "\n" |
383 | "/* Comment block in one line*/\n" |
384 | "enum Bar { FOOBAR, BARFOO };\n" |
385 | "\n" |
386 | "int bar3(int j, int k, const enum Bar b) {\n" |
387 | " // A comment\n" |
388 | " int r = j % k;\n" |
389 | " if (struct S = getS()) {\n" |
390 | " // if condition\n" |
391 | " }\n" |
392 | " return r;\n" |
393 | "}\n" |
394 | "} // namespace" ; |
395 | verifyFormat(Prefix + "\n\n\n" + Postfix, Style, |
396 | Prefix + removeEmptyLines(Postfix)); |
397 | } |
398 | |
399 | TEST_F(DefinitionBlockSeparatorTest, OpeningBracketOwnsLine) { |
400 | FormatStyle Style = getLLVMStyle(); |
401 | Style.BreakBeforeBraces = FormatStyle::BS_Allman; |
402 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
403 | verifyFormat("namespace NS\n" |
404 | "{\n" |
405 | "// Enum test1\n" |
406 | "// Enum test2\n" |
407 | "enum Foo\n" |
408 | "{\n" |
409 | " FOO,\n" |
410 | " BAR\n" |
411 | "};\n" |
412 | "\n" |
413 | "/*\n" |
414 | "test1\n" |
415 | "test2\n" |
416 | "*/\n" |
417 | "/*const*/ int foo(int i, int j)\n" |
418 | "{\n" |
419 | " int r = i + j;\n" |
420 | " return r;\n" |
421 | "}\n" |
422 | "\n" |
423 | "// Foobar\n" |
424 | "int i, j, k;\n" |
425 | "\n" |
426 | "// Comment for function\n" |
427 | "// Comment line 2\n" |
428 | "// Comment line 3\n" |
429 | "int bar(int j, int k)\n" |
430 | "{\n" |
431 | " {\n" |
432 | " int r = j * k;\n" |
433 | " return r;\n" |
434 | " }\n" |
435 | "}\n" |
436 | "\n" |
437 | "int bar2(int j, int k)\n" |
438 | "{\n" |
439 | " int r = j / k;\n" |
440 | " return r;\n" |
441 | "}\n" |
442 | "\n" |
443 | "enum Bar\n" |
444 | "{\n" |
445 | " FOOBAR,\n" |
446 | " BARFOO\n" |
447 | "};\n" |
448 | "\n" |
449 | "int bar3(int j, int k, const enum Bar b)\n" |
450 | "{\n" |
451 | " // A comment\n" |
452 | " int r = j % k;\n" |
453 | " if (struct S = getS())\n" |
454 | " {\n" |
455 | " // if condition\n" |
456 | " }\n" |
457 | " return r;\n" |
458 | "}\n" |
459 | "} // namespace NS" , |
460 | Style); |
461 | } |
462 | |
463 | TEST_F(DefinitionBlockSeparatorTest, TryBlocks) { |
464 | FormatStyle Style = getLLVMStyle(); |
465 | Style.BreakBeforeBraces = FormatStyle::BS_Allman; |
466 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
467 | verifyFormat("void FunctionWithInternalTry()\n" |
468 | "{\n" |
469 | " try\n" |
470 | " {\n" |
471 | " return;\n" |
472 | " }\n" |
473 | " catch (const std::exception &)\n" |
474 | " {\n" |
475 | " }\n" |
476 | "}" , |
477 | Style, "" , /*Inverse=*/false); |
478 | verifyFormat("void FunctionWithTryBlock()\n" |
479 | "try\n" |
480 | "{\n" |
481 | " return;\n" |
482 | "}\n" |
483 | "catch (const std::exception &)\n" |
484 | "{\n" |
485 | "}" , |
486 | Style, "" , /*Inverse=*/false); |
487 | } |
488 | |
489 | TEST_F(DefinitionBlockSeparatorTest, Leave) { |
490 | FormatStyle Style = getLLVMStyle(); |
491 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Leave; |
492 | Style.MaxEmptyLinesToKeep = 3; |
493 | std::string LeaveAs = "namespace {\n" |
494 | "\n" |
495 | "// Enum test1\n" |
496 | "// Enum test2\n" |
497 | "enum Foo { FOO, BAR };\n" |
498 | "\n\n\n" |
499 | "/*\n" |
500 | "test1\n" |
501 | "test2\n" |
502 | "*/\n" |
503 | "/*const*/ int foo(int i, int j) {\n" |
504 | " int r = i + j;\n" |
505 | " return r;\n" |
506 | "}\n" |
507 | "\n" |
508 | "// Foobar\n" |
509 | "int i, j, k;\n" |
510 | "\n" |
511 | "// Comment for function\n" |
512 | "// Comment line 2\n" |
513 | "// Comment line 3\n" |
514 | "int bar(int j, int k) {\n" |
515 | " {\n" |
516 | " int r = j * k;\n" |
517 | " return r;\n" |
518 | " }\n" |
519 | "}\n" |
520 | "\n" |
521 | "int bar2(int j, int k) {\n" |
522 | " int r = j / k;\n" |
523 | " return r;\n" |
524 | "}\n" |
525 | "\n" |
526 | "// Comment for inline enum\n" |
527 | "enum Bar { FOOBAR, BARFOO };\n" |
528 | "int bar3(int j, int k, const enum Bar b) {\n" |
529 | " // A comment\n" |
530 | " int r = j % k;\n" |
531 | " if (struct S = getS()) {\n" |
532 | " // if condition\n" |
533 | " }\n" |
534 | " return r;\n" |
535 | "}\n" |
536 | "} // namespace" ; |
537 | verifyFormat(LeaveAs, Style, LeaveAs); |
538 | } |
539 | |
540 | TEST_F(DefinitionBlockSeparatorTest, CSharp) { |
541 | FormatStyle Style = getLLVMStyle(Language: FormatStyle::LK_CSharp); |
542 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
543 | Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; |
544 | Style.AllowShortEnumsOnASingleLine = false; |
545 | verifyFormat("namespace {\r\n" |
546 | "public class SomeTinyClass {\r\n" |
547 | " int X;\r\n" |
548 | "}\r\n" |
549 | "\r\n" |
550 | "public class AnotherTinyClass {\r\n" |
551 | " int Y;\r\n" |
552 | "}\r\n" |
553 | "\r\n" |
554 | "internal static String toString() {\r\n" |
555 | "}\r\n" |
556 | "\r\n" |
557 | "// Comment for enum\r\n" |
558 | "public enum var {\r\n" |
559 | " none,\r\n" |
560 | " @string,\r\n" |
561 | " bool,\r\n" |
562 | " @enum\r\n" |
563 | "}\r\n" |
564 | "\r\n" |
565 | "// Test\r\n" |
566 | "[STAThread]\r\n" |
567 | "static void Main(string[] args) {\r\n" |
568 | " Console.WriteLine(\"HelloWorld\");\r\n" |
569 | "}\r\n" |
570 | "\r\n" |
571 | "static decimal Test() {\r\n" |
572 | "}\r\n" |
573 | "}\r\n" |
574 | "\r\n" |
575 | "public class FoobarClass {\r\n" |
576 | " int foobar;\r\n" |
577 | "}\r\n" |
578 | "\r\n" |
579 | "public class LogFactory<TLogger>\r\n" |
580 | " where TLogger : class, new() {\r\n" |
581 | " int i;\r\n" |
582 | "}" , |
583 | Style); |
584 | } |
585 | |
586 | TEST_F(DefinitionBlockSeparatorTest, JavaScript) { |
587 | FormatStyle Style = getLLVMStyle(Language: FormatStyle::LK_JavaScript); |
588 | Style.SeparateDefinitionBlocks = FormatStyle::SDS_Always; |
589 | Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None; |
590 | Style.AllowShortEnumsOnASingleLine = false; |
591 | verifyFormat("export const enum Foo {\n" |
592 | " A = 1,\n" |
593 | " B\n" |
594 | "}\n" |
595 | "\n" |
596 | "export function A() {\n" |
597 | "}\n" |
598 | "\n" |
599 | "export default function B() {\n" |
600 | "}\n" |
601 | "\n" |
602 | "export function C() {\n" |
603 | "}\n" |
604 | "\n" |
605 | "var t, p, q;\n" |
606 | "\n" |
607 | "export abstract class X {\n" |
608 | " y: number;\n" |
609 | "}\n" |
610 | "\n" |
611 | "export const enum Bar {\n" |
612 | " D = 1,\n" |
613 | " E\n" |
614 | "}" , |
615 | Style); |
616 | } |
617 | } // namespace |
618 | } // namespace format |
619 | } // namespace clang |
620 | |