blob: 4ae6b866b9f67fb3f07e127c1902bcf8a1a5c4f4 [file] [log] [blame]
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00001//===- unittest/Format/FormatTestJS.cpp - Formatting unit tests for JS ----===//
2//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000010#include "FormatTestUtils.h"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000011#include "clang/Format/Format.h"
12#include "llvm/Support/Debug.h"
13#include "gtest/gtest.h"
14
Chandler Carruth10346662014-04-22 03:17:02 +000015#define DEBUG_TYPE "format-test"
16
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000017namespace clang {
18namespace format {
19
20class FormatTestJS : public ::testing::Test {
21protected:
22 static std::string format(llvm::StringRef Code, unsigned Offset,
23 unsigned Length, const FormatStyle &Style) {
24 DEBUG(llvm::errs() << "---\n");
25 DEBUG(llvm::errs() << Code << "\n\n");
26 std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000027 FormattingAttemptStatus Status;
Daniel Jasper56691b82015-06-11 13:29:20 +000028 tooling::Replacements Replaces =
Krasimir Georgievbcda54b2017-04-21 14:35:20 +000029 reformat(Style, Code, Ranges, "<stdin>", &Status);
30 EXPECT_TRUE(Status.FormatComplete);
Eric Liu4f8d9942016-07-11 13:53:12 +000031 auto Result = applyAllReplacements(Code, Replaces);
32 EXPECT_TRUE(static_cast<bool>(Result));
33 DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
34 return *Result;
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000035 }
36
Daniel Jasper069e5f42014-05-20 11:14:57 +000037 static std::string format(
38 llvm::StringRef Code,
39 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000040 return format(Code, 0, Code.size(), Style);
41 }
42
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000043 static FormatStyle getGoogleJSStyleWithColumns(unsigned ColumnLimit) {
Nico Weber514ecc82014-02-02 20:50:45 +000044 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000045 Style.ColumnLimit = ColumnLimit;
46 return Style;
47 }
48
Nico Weber514ecc82014-02-02 20:50:45 +000049 static void verifyFormat(
50 llvm::StringRef Code,
51 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +000052 std::string Result = format(test::messUp(Code), Style);
53 EXPECT_EQ(Code.str(), Result) << "Formatted:\n" << Result;
54 }
55
56 static void verifyFormat(
57 llvm::StringRef Expected,
58 llvm::StringRef Code,
59 const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
60 std::string Result = format(Code, Style);
61 EXPECT_EQ(Expected.str(), Result) << "Formatted:\n" << Result;
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000062 }
63};
64
Daniel Jaspere77f19c2016-05-29 22:07:22 +000065TEST_F(FormatTestJS, BlockComments) {
66 verifyFormat("/* aaaaaaaaaaaaa */ aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
67 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
68}
69
Krasimir Georgiev22d7e6b2017-07-20 22:29:39 +000070TEST_F(FormatTestJS, JSDocComments) {
71 // Break the first line of a multiline jsdoc comment.
72 EXPECT_EQ("/**\n"
73 " * jsdoc line 1\n"
74 " * jsdoc line 2\n"
75 " */",
76 format("/** jsdoc line 1\n"
77 " * jsdoc line 2\n"
78 " */",
79 getGoogleJSStyleWithColumns(20)));
80 // Both break after '/**' and break the line itself.
81 EXPECT_EQ("/**\n"
82 " * jsdoc line long\n"
83 " * long jsdoc line 2\n"
84 " */",
85 format("/** jsdoc line long long\n"
86 " * jsdoc line 2\n"
87 " */",
88 getGoogleJSStyleWithColumns(20)));
89 // Break a short first line if the ending '*/' is on a newline.
90 EXPECT_EQ("/**\n"
91 " * jsdoc line 1\n"
92 " */",
93 format("/** jsdoc line 1\n"
94 " */", getGoogleJSStyleWithColumns(20)));
95 // Don't break the first line of a short single line jsdoc comment.
96 EXPECT_EQ("/** jsdoc line 1 */",
97 format("/** jsdoc line 1 */", getGoogleJSStyleWithColumns(20)));
98 // Don't break the first line of a single line jsdoc comment if it just fits
99 // the column limit.
100 EXPECT_EQ("/** jsdoc line 12 */",
101 format("/** jsdoc line 12 */", getGoogleJSStyleWithColumns(20)));
102 // Don't break after '/**' and before '*/' if there is no space between
103 // '/**' and the content.
104 EXPECT_EQ(
105 "/*** nonjsdoc long\n"
106 " * line */",
107 format("/*** nonjsdoc long line */", getGoogleJSStyleWithColumns(20)));
108 EXPECT_EQ(
109 "/**strange long long\n"
110 " * line */",
111 format("/**strange long long line */", getGoogleJSStyleWithColumns(20)));
112 // Break the first line of a single line jsdoc comment if it just exceeds the
113 // column limit.
114 EXPECT_EQ("/**\n"
115 " * jsdoc line 123\n"
116 " */",
117 format("/** jsdoc line 123 */", getGoogleJSStyleWithColumns(20)));
118 // Break also if the leading indent of the first line is more than 1 column.
119 EXPECT_EQ("/**\n"
120 " * jsdoc line 123\n"
121 " */",
122 format("/** jsdoc line 123 */", getGoogleJSStyleWithColumns(20)));
123 // Break also if the leading indent of the first line is more than 1 column.
124 EXPECT_EQ("/**\n"
125 " * jsdoc line 123\n"
126 " */",
127 format("/** jsdoc line 123 */", getGoogleJSStyleWithColumns(20)));
128 // Break after the content of the last line.
129 EXPECT_EQ("/**\n"
130 " * line 1\n"
131 " * line 2\n"
132 " */",
133 format("/**\n"
134 " * line 1\n"
135 " * line 2 */",
136 getGoogleJSStyleWithColumns(20)));
137 // Break both the content and after the content of the last line.
138 EXPECT_EQ("/**\n"
139 " * line 1\n"
140 " * line long long\n"
141 " * long\n"
142 " */",
143 format("/**\n"
144 " * line 1\n"
145 " * line long long long */",
146 getGoogleJSStyleWithColumns(20)));
147
148 // The comment block gets indented.
149 EXPECT_EQ("function f() {\n"
150 " /**\n"
151 " * comment about\n"
152 " * x\n"
153 " */\n"
154 " var x = 1;\n"
155 "}",
156 format("function f() {\n"
157 "/** comment about x */\n"
158 "var x = 1;\n"
159 "}",
160 getGoogleJSStyleWithColumns(20)));
161}
162
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000163TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
164 verifyFormat("a == = b;");
165 verifyFormat("a != = b;");
166
167 verifyFormat("a === b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +0000168 verifyFormat("aaaaaaa ===\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000169 verifyFormat("a !== b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +0000170 verifyFormat("aaaaaaa !==\n b;", getGoogleJSStyleWithColumns(10));
171 verifyFormat("if (a + b + c +\n"
172 " d !==\n"
173 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000174 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000175 getGoogleJSStyleWithColumns(20));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000176
177 verifyFormat("a >> >= b;");
178
179 verifyFormat("a >>> b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +0000180 verifyFormat("aaaaaaa >>>\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000181 verifyFormat("a >>>= b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +0000182 verifyFormat("aaaaaaa >>>=\n b;", getGoogleJSStyleWithColumns(10));
183 verifyFormat("if (a + b + c +\n"
184 " d >>>\n"
185 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000186 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000187 getGoogleJSStyleWithColumns(20));
Daniel Jaspere551bb72014-11-05 17:22:31 +0000188 verifyFormat("var x = aaaaaaaaaa ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000189 " bbbbbb :\n"
190 " ccc;",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +0000191 getGoogleJSStyleWithColumns(20));
Daniel Jasper78214392014-05-19 07:27:02 +0000192
193 verifyFormat("var b = a.map((x) => x + 1);");
Daniel Jasper3549ea12014-09-19 10:48:15 +0000194 verifyFormat("return ('aaa') in bbbb;");
Daniel Jasper1ce41112016-02-01 11:20:47 +0000195 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
196 " aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
197 FormatStyle Style = getGoogleJSStyleWithColumns(80);
198 Style.AlignOperands = true;
199 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
200 " aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
201 Style);
202 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
203 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa()\n"
204 " in aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
205 Style);
Daniel Jasper08051992015-05-26 07:18:56 +0000206
207 // ES6 spread operator.
208 verifyFormat("someFunction(...a);");
209 verifyFormat("var x = [1, ...a, 2];");
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000210}
211
Daniel Jasper3a038de2014-09-05 08:53:45 +0000212TEST_F(FormatTestJS, UnderstandsAmpAmp) {
213 verifyFormat("e && e.SomeFunction();");
214}
215
Daniel Jasper4db69bd2014-09-04 18:23:42 +0000216TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
217 verifyFormat("not.and.or.not_eq = 1;");
218}
219
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000220TEST_F(FormatTestJS, ReservedWords) {
221 // JavaScript reserved words (aka keywords) are only illegal when used as
222 // Identifiers, but are legal as IdentifierNames.
223 verifyFormat("x.class.struct = 1;");
224 verifyFormat("x.case = 1;");
225 verifyFormat("x.interface = 1;");
Daniel Jasper997cf2f2016-05-20 06:16:01 +0000226 verifyFormat("x.for = 1;");
Daniel Jaspera4607e12016-03-17 12:17:59 +0000227 verifyFormat("x.of() = 1;");
Martin Probstc4a3d082017-04-05 10:56:07 +0000228 verifyFormat("of(null);");
229 verifyFormat("import {of} from 'x';");
Daniel Jaspera4607e12016-03-17 12:17:59 +0000230 verifyFormat("x.in() = 1;");
231 verifyFormat("x.let() = 1;");
232 verifyFormat("x.var() = 1;");
Daniel Jasper4d67dd72016-11-01 06:22:54 +0000233 verifyFormat("x.for() = 1;");
Daniel Jasperb559b432016-11-01 06:23:10 +0000234 verifyFormat("x.as() = 1;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000235 verifyFormat("x = {\n"
236 " a: 12,\n"
237 " interface: 1,\n"
238 " switch: 1,\n"
239 "};");
Daniel Jasper09840ef2015-11-20 15:58:50 +0000240 verifyFormat("var struct = 2;");
241 verifyFormat("var union = 2;");
Martin Probst1e8261e2016-04-19 18:18:59 +0000242 verifyFormat("var interface = 2;");
243 verifyFormat("interface = 2;");
244 verifyFormat("x = interface instanceof y;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000245}
246
Martin Probst4210d2f2016-09-22 07:18:00 +0000247TEST_F(FormatTestJS, ReservedWordsMethods) {
248 verifyFormat(
249 "class X {\n"
250 " delete() {\n"
251 " x();\n"
252 " }\n"
253 " interface() {\n"
254 " x();\n"
255 " }\n"
256 " let() {\n"
257 " x();\n"
258 " }\n"
259 "}\n");
260}
261
Martin Probst22e00f02017-08-01 17:22:15 +0000262TEST_F(FormatTestJS, ReservedWordsParenthesized) {
263 // All of these are statements using the keyword, not function calls.
264 verifyFormat("throw (x + y);\n"
265 "await (await x).y;\n"
266 "void (0);\n"
267 "delete (x.y);\n"
268 "return (x);\n");
269}
270
Daniel Jasper72a1b6a2015-12-22 15:47:56 +0000271TEST_F(FormatTestJS, CppKeywords) {
272 // Make sure we don't mess stuff up because of C++ keywords.
273 verifyFormat("return operator && (aa);");
Daniel Jasper72b33572017-03-31 12:04:37 +0000274 // .. or QT ones.
275 verifyFormat("slots: Slot[];");
Daniel Jasper72a1b6a2015-12-22 15:47:56 +0000276}
277
Daniel Jasper0dd52912014-05-19 07:37:07 +0000278TEST_F(FormatTestJS, ES6DestructuringAssignment) {
279 verifyFormat("var [a, b, c] = [1, 2, 3];");
Daniel Jasper5dbcd3b2016-05-19 07:18:07 +0000280 verifyFormat("const [a, b, c] = [1, 2, 3];");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000281 verifyFormat("let [a, b, c] = [1, 2, 3];");
Daniel Jasper60948b12015-03-15 13:55:54 +0000282 verifyFormat("var {a, b} = {a: 1, b: 2};");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000283 verifyFormat("let {a, b} = {a: 1, b: 2};");
Daniel Jasper0dd52912014-05-19 07:37:07 +0000284}
285
Daniel Jasper17062ff2014-06-10 14:44:02 +0000286TEST_F(FormatTestJS, ContainerLiterals) {
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000287 verifyFormat("var x = {\n"
288 " y: function(a) {\n"
289 " return a;\n"
290 " }\n"
291 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000292 verifyFormat("return {\n"
293 " link: function() {\n"
294 " f(); //\n"
295 " }\n"
296 "};");
297 verifyFormat("return {\n"
298 " a: a,\n"
299 " link: function() {\n"
300 " f(); //\n"
301 " }\n"
302 "};");
303 verifyFormat("return {\n"
304 " a: a,\n"
Daniel Jasper90ebc982014-09-05 09:27:38 +0000305 " link: function() {\n"
306 " f(); //\n"
307 " },\n"
308 " link: function() {\n"
309 " f(); //\n"
310 " }\n"
Daniel Jasper17062ff2014-06-10 14:44:02 +0000311 "};");
Daniel Jasper94e11d02014-09-04 14:58:30 +0000312 verifyFormat("var stuff = {\n"
313 " // comment for update\n"
314 " update: false,\n"
315 " // comment for modules\n"
316 " modules: false,\n"
317 " // comment for tasks\n"
318 " tasks: false\n"
319 "};");
Daniel Jasper97bfb7b2014-09-05 08:29:31 +0000320 verifyFormat("return {\n"
321 " 'finish':\n"
322 " //\n"
323 " a\n"
324 "};");
Daniel Jasper40874322014-11-27 15:24:48 +0000325 verifyFormat("var obj = {\n"
326 " fooooooooo: function(x) {\n"
327 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
328 " }\n"
329 "};");
Daniel Jasper60948b12015-03-15 13:55:54 +0000330 // Simple object literal, as opposed to enum style below.
331 verifyFormat("var obj = {a: 123};");
332 // Enum style top level assignment.
333 verifyFormat("X = {\n a: 123\n};");
334 verifyFormat("X.Y = {\n a: 123\n};");
Daniel Jasper11ca2632015-06-10 09:21:09 +0000335 // But only on the top level, otherwise its a plain object literal assignment.
336 verifyFormat("function x() {\n"
337 " y = {z: 1};\n"
338 "}");
Daniel Jasper60948b12015-03-15 13:55:54 +0000339 verifyFormat("x = foo && {a: 123};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000340
341 // Arrow functions in object literals.
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000342 verifyFormat("var x = {\n"
343 " y: (a) => {\n"
344 " return a;\n"
345 " }\n"
346 "};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000347 verifyFormat("var x = {y: (a) => a};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000348
Martin Probst8e3eba02017-02-07 16:33:13 +0000349 // Methods in object literals.
350 verifyFormat("var x = {\n"
351 " y(a: string): number {\n"
352 " return a;\n"
353 " }\n"
354 "};");
355 verifyFormat("var x = {\n"
356 " y(a: string) {\n"
357 " return a;\n"
358 " }\n"
359 "};");
360
Daniel Jasper8c42d442015-05-29 06:19:49 +0000361 // Computed keys.
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000362 verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000363 verifyFormat("var x = {\n"
364 " [a]: 1,\n"
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000365 " b: 2,\n"
366 " [c]: 3,\n"
Daniel Jasper8c42d442015-05-29 06:19:49 +0000367 "};");
Daniel Jasper9f4c9d42016-02-07 22:17:13 +0000368
369 // Object literals can leave out labels.
370 verifyFormat("f({a}, () => {\n"
371 " g(); //\n"
372 "});");
Daniel Jasperb18425b2016-03-01 04:19:47 +0000373
374 // Keys can be quoted.
375 verifyFormat("var x = {\n"
376 " a: a,\n"
377 " b: b,\n"
378 " 'c': c,\n"
379 "};");
Daniel Jaspere98e5812016-11-29 09:40:36 +0000380
381 // Dict literals can skip the label names.
382 verifyFormat("var x = {\n"
383 " aaa,\n"
384 " aaa,\n"
385 " aaa,\n"
386 "};");
Daniel Jasper893b8ad2017-03-01 19:47:28 +0000387 verifyFormat("return {\n"
388 " a,\n"
389 " b: 'b',\n"
390 " c,\n"
391 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000392}
393
Daniel Jasperf46dec82015-03-31 14:34:15 +0000394TEST_F(FormatTestJS, MethodsInObjectLiterals) {
395 verifyFormat("var o = {\n"
396 " value: 'test',\n"
397 " get value() { // getter\n"
398 " return this.value;\n"
399 " }\n"
400 "};");
401 verifyFormat("var o = {\n"
402 " value: 'test',\n"
403 " set value(val) { // setter\n"
404 " this.value = val;\n"
405 " }\n"
406 "};");
407 verifyFormat("var o = {\n"
408 " value: 'test',\n"
409 " someMethod(val) { // method\n"
410 " doSomething(this.value + val);\n"
411 " }\n"
412 "};");
Daniel Jasper739ec532015-04-04 07:56:55 +0000413 verifyFormat("var o = {\n"
414 " someMethod(val) { // method\n"
415 " doSomething(this.value + val);\n"
416 " },\n"
417 " someOtherMethod(val) { // method\n"
418 " doSomething(this.value + val);\n"
419 " }\n"
420 "};");
Daniel Jasperf46dec82015-03-31 14:34:15 +0000421}
422
Martin Probst19c7de02017-04-26 12:34:15 +0000423TEST_F(FormatTestJS, GettersSettersVisibilityKeywords) {
424 // Don't break after "protected"
425 verifyFormat("class X {\n"
426 " protected get getter():\n"
427 " number {\n"
428 " return 1;\n"
429 " }\n"
430 "}",
431 getGoogleJSStyleWithColumns(12));
432 // Don't break after "get"
433 verifyFormat("class X {\n"
434 " protected get someReallyLongGetterName():\n"
435 " number {\n"
436 " return 1;\n"
437 " }\n"
438 "}",
439 getGoogleJSStyleWithColumns(40));
440}
441
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000442TEST_F(FormatTestJS, SpacesInContainerLiterals) {
443 verifyFormat("var arr = [1, 2, 3];");
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000444 verifyFormat("f({a: 1, b: 2, c: 3});");
Nico Weber514ecc82014-02-02 20:50:45 +0000445
Daniel Jasper2a958322014-05-21 13:26:58 +0000446 verifyFormat("var object_literal_with_long_name = {\n"
447 " a: 'aaaaaaaaaaaaaaaaaa',\n"
448 " b: 'bbbbbbbbbbbbbbbbbb'\n"
449 "};");
450
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000451 verifyFormat("f({a: 1, b: 2, c: 3});",
Nico Weber514ecc82014-02-02 20:50:45 +0000452 getChromiumStyle(FormatStyle::LK_JavaScript));
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000453 verifyFormat("f({'a': [{}]});");
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000454}
455
Daniel Jasperabd1f572016-03-02 22:44:03 +0000456TEST_F(FormatTestJS, SingleQuotedStrings) {
Daniel Jasper86fee2f2014-01-31 12:49:42 +0000457 verifyFormat("this.function('', true);");
458}
459
Daniel Jasper4a39c842014-05-06 13:54:10 +0000460TEST_F(FormatTestJS, GoogScopes) {
461 verifyFormat("goog.scope(function() {\n"
462 "var x = a.b;\n"
463 "var y = c.d;\n"
464 "}); // goog.scope");
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000465 verifyFormat("goog.scope(function() {\n"
466 "// test\n"
467 "var x = 0;\n"
468 "// test\n"
469 "});");
Daniel Jasper4a39c842014-05-06 13:54:10 +0000470}
471
Martin Probst101ec892017-05-09 20:04:09 +0000472TEST_F(FormatTestJS, IIFEs) {
473 // Internal calling parens; no semi.
474 verifyFormat("(function() {\n"
475 "var a = 1;\n"
476 "}())");
477 // External calling parens; no semi.
478 verifyFormat("(function() {\n"
479 "var b = 2;\n"
480 "})()");
481 // Internal calling parens; with semi.
482 verifyFormat("(function() {\n"
483 "var c = 3;\n"
484 "}());");
485 // External calling parens; with semi.
486 verifyFormat("(function() {\n"
487 "var d = 4;\n"
488 "})();");
489}
490
Daniel Jasper616de8642014-11-23 16:46:28 +0000491TEST_F(FormatTestJS, GoogModules) {
492 verifyFormat("goog.module('this.is.really.absurdly.long');",
493 getGoogleJSStyleWithColumns(40));
494 verifyFormat("goog.require('this.is.really.absurdly.long');",
495 getGoogleJSStyleWithColumns(40));
496 verifyFormat("goog.provide('this.is.really.absurdly.long');",
497 getGoogleJSStyleWithColumns(40));
498 verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
499 getGoogleJSStyleWithColumns(40));
Daniel Jasperb488a742015-10-29 19:05:20 +0000500 verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
501 getGoogleJSStyleWithColumns(40));
Daniel Jasper02cbeb22016-02-22 15:06:53 +0000502 verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
503 getGoogleJSStyleWithColumns(40));
Daniel Jasper53c38f42014-11-27 14:46:03 +0000504
505 // These should be wrapped normally.
506 verifyFormat(
507 "var MyLongClassName =\n"
508 " goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
Daniel Jasper616de8642014-11-23 16:46:28 +0000509}
510
Martin Probstece8c0c2016-06-13 16:41:28 +0000511TEST_F(FormatTestJS, FormatsNamespaces) {
512 verifyFormat("namespace Foo {\n"
513 " export let x = 1;\n"
514 "}\n");
515 verifyFormat("declare namespace Foo {\n"
516 " export let x: number;\n"
517 "}\n");
518}
519
Martin Probst72fd75a2016-11-10 16:20:58 +0000520TEST_F(FormatTestJS, NamespacesMayNotWrap) {
521 verifyFormat("declare namespace foobarbaz {\n"
522 "}\n", getGoogleJSStyleWithColumns(18));
523 verifyFormat("declare module foobarbaz {\n"
524 "}\n", getGoogleJSStyleWithColumns(15));
525 verifyFormat("namespace foobarbaz {\n"
526 "}\n", getGoogleJSStyleWithColumns(10));
527 verifyFormat("module foobarbaz {\n"
528 "}\n", getGoogleJSStyleWithColumns(7));
529}
530
531TEST_F(FormatTestJS, AmbientDeclarations) {
532 FormatStyle NineCols = getGoogleJSStyleWithColumns(9);
533 verifyFormat(
534 "declare class\n"
535 " X {}",
536 NineCols);
537 verifyFormat(
538 "declare function\n"
539 "x();", // TODO(martinprobst): should ideally be indented.
540 NineCols);
Martin Probstaf16c502017-01-04 13:36:43 +0000541 verifyFormat("declare function foo();\n"
542 "let x = 1;\n");
543 verifyFormat("declare function foo(): string;\n"
544 "let x = 1;\n");
545 verifyFormat("declare function foo(): {x: number};\n"
546 "let x = 1;\n");
547 verifyFormat("declare class X {}\n"
548 "let x = 1;\n");
549 verifyFormat("declare interface Y {}\n"
550 "let x = 1;\n");
Martin Probst72fd75a2016-11-10 16:20:58 +0000551 verifyFormat(
552 "declare enum X {\n"
553 "}",
554 NineCols);
555 verifyFormat(
556 "declare let\n"
557 " x: number;",
558 NineCols);
559}
560
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000561TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
562 verifyFormat("function outer1(a, b) {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000563 " function inner1(a, b) {\n"
564 " return a;\n"
565 " }\n"
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000566 " inner1(a, b);\n"
567 "}\n"
568 "function outer2(a, b) {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000569 " function inner2(a, b) {\n"
570 " return a;\n"
571 " }\n"
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000572 " inner2(a, b);\n"
573 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000574 verifyFormat("function f() {}");
Martin Probstb7fb2672017-05-10 13:53:29 +0000575 verifyFormat("function aFunction() {}\n"
576 "(function f() {\n"
577 " var x = 1;\n"
578 "}());\n");
Martin Probst95ed8e72017-05-31 09:29:40 +0000579 verifyFormat("function aFunction() {}\n"
580 "{\n"
Martin Probstb7fb2672017-05-10 13:53:29 +0000581 " let x = 1;\n"
582 " console.log(x);\n"
583 "}\n");
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000584}
585
Martin Probst5f8445b2016-04-24 22:05:09 +0000586TEST_F(FormatTestJS, GeneratorFunctions) {
587 verifyFormat("function* f() {\n"
588 " let x = 1;\n"
589 " yield x;\n"
590 " yield* something();\n"
Daniel Jaspereb886632016-10-31 13:18:25 +0000591 " yield [1, 2];\n"
592 " yield {a: 1};\n"
Martin Probst5f8445b2016-04-24 22:05:09 +0000593 "}");
594 verifyFormat("function*\n"
595 " f() {\n"
596 "}",
597 getGoogleJSStyleWithColumns(8));
598 verifyFormat("export function* f() {\n"
599 " yield 1;\n"
600 "}\n");
601 verifyFormat("class X {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000602 " * generatorMethod() {\n"
603 " yield x;\n"
604 " }\n"
Martin Probst5f8445b2016-04-24 22:05:09 +0000605 "}");
Daniel Jasper71e50af2016-11-01 06:22:59 +0000606 verifyFormat("var x = {\n"
607 " a: function*() {\n"
608 " //\n"
609 " }\n"
610 "}\n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000611}
612
613TEST_F(FormatTestJS, AsyncFunctions) {
614 verifyFormat("async function f() {\n"
615 " let x = 1;\n"
616 " return fetch(x);\n"
617 "}");
Martin Probst973ff792017-04-27 13:07:24 +0000618 verifyFormat("async function f() {\n"
619 " return 1;\n"
620 "}\n"
621 "\n"
622 "function a() {\n"
623 " return 1;\n"
624 "}\n",
625 " async function f() {\n"
626 " return 1;\n"
627 "}\n"
628 "\n"
629 " function a() {\n"
630 " return 1;\n"
631 "} \n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000632 verifyFormat("async function* f() {\n"
633 " yield fetch(x);\n"
634 "}");
635 verifyFormat("export async function f() {\n"
636 " return fetch(x);\n"
637 "}");
Martin Probst20371c32017-02-27 11:15:53 +0000638 verifyFormat("let x = async () => f();");
Martin Probst973ff792017-04-27 13:07:24 +0000639 verifyFormat("let x = async function() {\n"
640 " f();\n"
641 "};");
Martin Probst20371c32017-02-27 11:15:53 +0000642 verifyFormat("let x = async();");
Martin Probst5f8445b2016-04-24 22:05:09 +0000643 verifyFormat("class X {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000644 " async asyncMethod() {\n"
645 " return fetch(1);\n"
646 " }\n"
Martin Probst5f8445b2016-04-24 22:05:09 +0000647 "}");
Martin Probst409697e2016-05-29 14:41:07 +0000648 verifyFormat("function initialize() {\n"
649 " // Comment.\n"
650 " return async.then();\n"
651 "}\n");
Martin Probsta050f412017-05-18 21:19:29 +0000652 verifyFormat("for await (const x of y) {\n"
Martin Probstbd49e322017-05-15 19:33:20 +0000653 " console.log(x);\n"
654 "}\n");
655 verifyFormat("function asyncLoop() {\n"
Martin Probsta050f412017-05-18 21:19:29 +0000656 " for await (const x of y) {\n"
Martin Probstbd49e322017-05-15 19:33:20 +0000657 " console.log(x);\n"
658 " }\n"
659 "}\n");
Martin Probst5f8445b2016-04-24 22:05:09 +0000660}
661
Martin Probst2c1cdae2017-05-15 11:15:29 +0000662TEST_F(FormatTestJS, FunctionParametersTrailingComma) {
663 verifyFormat("function trailingComma(\n"
664 " p1,\n"
665 " p2,\n"
666 " p3,\n"
667 ") {\n"
668 " a; //\n"
669 "}\n",
670 "function trailingComma(p1, p2, p3,) {\n"
671 " a; //\n"
672 "}\n");
673 verifyFormat("trailingComma(\n"
674 " p1,\n"
675 " p2,\n"
676 " p3,\n"
677 ");\n",
678 "trailingComma(p1, p2, p3,);\n");
679 verifyFormat("trailingComma(\n"
680 " p1 // hello\n"
681 ");\n",
682 "trailingComma(p1 // hello\n"
683 ");\n");
684}
685
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000686TEST_F(FormatTestJS, ArrayLiterals) {
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000687 verifyFormat("var aaaaa: List<SomeThing> =\n"
688 " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000689 verifyFormat("return [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000690 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000691 " ccccccccccccccccccccccccccc\n"
692 "];");
Daniel Jasper7bec87c2016-01-07 18:11:54 +0000693 verifyFormat("return [\n"
694 " aaaa().bbbbbbbb('A'),\n"
695 " aaaa().bbbbbbbb('B'),\n"
696 " aaaa().bbbbbbbb('C'),\n"
697 "];");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000698 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000699 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper5ce80de2015-06-02 13:56:43 +0000700 " ccccccccccccccccccccccccccc\n"
701 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000702 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper40432ce2015-06-02 15:04:29 +0000703 " [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
Daniel Jasper199d0c92015-06-02 15:14:21 +0000704 "]);",
705 getGoogleJSStyleWithColumns(51));
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000706 verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000707 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper4284e362015-06-02 14:20:08 +0000708 " ccccccccccccccccccccccccccc\n"
709 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000710 verifyFormat("var someVariable = SomeFunction(\n"
711 " aaaa,\n"
712 " [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000713 " aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
714 " cccccccccccccccccccccccccc\n"
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000715 " ],\n"
716 " aaaa);");
Daniel Jasperebcb71f2016-01-04 13:11:41 +0000717 verifyFormat("var aaaa = aaaaa || // wrap\n"
718 " [];");
Daniel Jasper1feab0f2015-06-02 15:31:37 +0000719
720 verifyFormat("someFunction([], {a: a});");
Daniel Jasper51c868e2017-01-30 07:08:40 +0000721
722 verifyFormat("var string = [\n"
723 " 'aaaaaa',\n"
724 " 'bbbbbb',\n"
725 "].join('+');");
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000726}
727
Daniel Jaspere2deb592015-12-22 15:48:15 +0000728TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
729 verifyFormat("var array = [\n"
730 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
731 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
732 "];");
733 verifyFormat("var array = someFunction([\n"
734 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
735 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
736 "]);");
737}
738
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000739TEST_F(FormatTestJS, FunctionLiterals) {
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000740 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
741 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
Daniel Jasper3f69ba12014-09-05 08:42:27 +0000742 verifyFormat("doFoo(function() {});");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000743 verifyFormat("doFoo(function() { return 1; });", Style);
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000744 verifyFormat("var func = function() {\n"
745 " return 1;\n"
746 "};");
Daniel Jaspered3f3952015-06-18 12:32:59 +0000747 verifyFormat("var func = //\n"
748 " function() {\n"
749 " return 1;\n"
750 "};");
Daniel Jasperc03e16a2014-05-08 09:25:39 +0000751 verifyFormat("return {\n"
752 " body: {\n"
753 " setAttribute: function(key, val) { this[key] = val; },\n"
754 " getAttribute: function(key) { return this[key]; },\n"
755 " style: {direction: ''}\n"
756 " }\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000757 "};",
758 Style);
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000759 verifyFormat("abc = xyz ? function() {\n"
760 " return 1;\n"
761 "} : function() {\n"
762 " return -1;\n"
763 "};");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000764
765 verifyFormat("var closure = goog.bind(\n"
766 " function() { // comment\n"
767 " foo();\n"
768 " bar();\n"
769 " },\n"
Joerg Sonnenbergere9987a12017-01-05 17:59:44 +0000770 " this, arg1IsReallyLongAndNeedsLineBreaks,\n"
771 " arg3IsReallyLongAndNeedsLineBreaks);");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000772 verifyFormat("var closure = goog.bind(function() { // comment\n"
773 " foo();\n"
774 " bar();\n"
775 "}, this);");
Daniel Jasper58cb2ed2014-06-06 13:49:04 +0000776 verifyFormat("return {\n"
777 " a: 'E',\n"
778 " b: function() {\n"
779 " return function() {\n"
780 " f(); //\n"
781 " };\n"
782 " }\n"
783 "};");
Daniel Jasper41368e92014-11-27 15:37:42 +0000784 verifyFormat("{\n"
785 " var someVariable = function(x) {\n"
786 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
787 " };\n"
788 "}");
Daniel Jasper7325aee2015-05-08 08:38:52 +0000789 verifyFormat("someLooooooooongFunction(\n"
790 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
791 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
792 " function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
793 " // code\n"
794 " });");
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000795
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000796 verifyFormat("return {\n"
797 " a: function SomeFunction() {\n"
798 " // ...\n"
799 " return 1;\n"
800 " }\n"
801 "};");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000802 verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
803 " .then(goog.bind(function(aaaaaaaaaaa) {\n"
804 " someFunction();\n"
805 " someFunction();\n"
806 " }, this), aaaaaaaaaaaaaaaaa);");
807
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000808 verifyFormat("someFunction(goog.bind(function() {\n"
809 " doSomething();\n"
810 " doSomething();\n"
811 "}, this), goog.bind(function() {\n"
812 " doSomething();\n"
813 " doSomething();\n"
814 "}, this));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000815
Daniel Jasper51c868e2017-01-30 07:08:40 +0000816 verifyFormat("SomeFunction(function() {\n"
817 " foo();\n"
818 " bar();\n"
819 "}.bind(this));");
820
Martin Probstb2f06ea2017-05-29 07:50:52 +0000821 verifyFormat("SomeFunction((function() {\n"
822 " foo();\n"
823 " bar();\n"
824 " }).bind(this));");
825
Daniel Jasper1699eca2015-06-01 09:56:32 +0000826 // FIXME: This is bad, we should be wrapping before "function() {".
827 verifyFormat("someFunction(function() {\n"
828 " doSomething(); // break\n"
829 "})\n"
830 " .doSomethingElse(\n"
831 " // break\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +0000832 " );");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000833
834 Style.ColumnLimit = 33;
835 verifyFormat("f({a: function() { return 1; }});", Style);
836 Style.ColumnLimit = 32;
837 verifyFormat("f({\n"
838 " a: function() { return 1; }\n"
839 "});",
840 Style);
841
Daniel Jasper79dffb42014-05-07 09:48:30 +0000842}
843
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000844TEST_F(FormatTestJS, InliningFunctionLiterals) {
845 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
846 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
847 verifyFormat("var func = function() {\n"
848 " return 1;\n"
849 "};",
850 Style);
851 verifyFormat("var func = doSomething(function() { return 1; });", Style);
852 verifyFormat("var outer = function() {\n"
853 " var inner = function() { return 1; }\n"
854 "};",
855 Style);
856 verifyFormat("function outer1(a, b) {\n"
857 " function inner1(a, b) { return a; }\n"
858 "}",
859 Style);
860
861 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
862 verifyFormat("var func = function() { return 1; };", Style);
863 verifyFormat("var func = doSomething(function() { return 1; });", Style);
864 verifyFormat(
865 "var outer = function() { var inner = function() { return 1; } };",
866 Style);
867 verifyFormat("function outer1(a, b) {\n"
868 " function inner1(a, b) { return a; }\n"
869 "}",
870 Style);
871
872 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
873 verifyFormat("var func = function() {\n"
874 " return 1;\n"
875 "};",
876 Style);
877 verifyFormat("var func = doSomething(function() {\n"
878 " return 1;\n"
879 "});",
880 Style);
881 verifyFormat("var outer = function() {\n"
882 " var inner = function() {\n"
883 " return 1;\n"
884 " }\n"
885 "};",
886 Style);
887 verifyFormat("function outer1(a, b) {\n"
888 " function inner1(a, b) {\n"
889 " return a;\n"
890 " }\n"
891 "}",
892 Style);
Daniel Jasper71e57452015-11-20 16:44:28 +0000893
894 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
895 verifyFormat("var func = function() {\n"
896 " return 1;\n"
897 "};",
898 Style);
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000899}
900
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000901TEST_F(FormatTestJS, MultipleFunctionLiterals) {
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000902 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
903 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000904 verifyFormat("promise.then(\n"
905 " function success() {\n"
906 " doFoo();\n"
907 " doBar();\n"
908 " },\n"
909 " function error() {\n"
910 " doFoo();\n"
911 " doBaz();\n"
912 " },\n"
913 " []);\n");
914 verifyFormat("promise.then(\n"
915 " function success() {\n"
916 " doFoo();\n"
917 " doBar();\n"
918 " },\n"
919 " [],\n"
920 " function error() {\n"
921 " doFoo();\n"
922 " doBaz();\n"
923 " });\n");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000924 verifyFormat("promise.then(\n"
925 " [],\n"
926 " function success() {\n"
927 " doFoo();\n"
928 " doBar();\n"
929 " },\n"
930 " function error() {\n"
931 " doFoo();\n"
932 " doBaz();\n"
933 " });\n");
Daniel Jasper1779d432014-09-29 07:54:54 +0000934
935 verifyFormat("getSomeLongPromise()\n"
936 " .then(function(value) { body(); })\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000937 " .thenCatch(function(error) {\n"
938 " body();\n"
939 " body();\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000940 " });",
941 Style);
Daniel Jasper1779d432014-09-29 07:54:54 +0000942 verifyFormat("getSomeLongPromise()\n"
943 " .then(function(value) {\n"
944 " body();\n"
945 " body();\n"
946 " })\n"
947 " .thenCatch(function(error) {\n"
948 " body();\n"
949 " body();\n"
950 " });");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000951
Daniel Jasperacf67e32015-04-07 08:20:35 +0000952 verifyFormat("getSomeLongPromise()\n"
953 " .then(function(value) { body(); })\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000954 " .thenCatch(function(error) { body(); });",
955 Style);
Daniel Jasper28024562016-01-11 11:00:58 +0000956
957 verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
958 " .aaaaaaa(function() {\n"
959 " //\n"
960 " })\n"
961 " .bbbbbb();");
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000962}
963
Manuel Klimek79e06082015-05-21 12:23:34 +0000964TEST_F(FormatTestJS, ArrowFunctions) {
965 verifyFormat("var x = (a) => {\n"
966 " return a;\n"
967 "};");
968 verifyFormat("var x = (a) => {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +0000969 " function y() {\n"
970 " return 42;\n"
971 " }\n"
Manuel Klimek79e06082015-05-21 12:23:34 +0000972 " return a;\n"
973 "};");
974 verifyFormat("var x = (a: type): {some: type} => {\n"
975 " return a;\n"
976 "};");
977 verifyFormat("var x = (a) => a;");
Daniel Jaspere497bed2015-06-02 22:06:07 +0000978 verifyFormat("return () => [];");
Daniel Jasper3c306e82015-06-03 17:08:40 +0000979 verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
980 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
981 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
982 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
Daniel Jasper3b0f3042015-06-05 08:25:37 +0000983 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper3c306e82015-06-03 17:08:40 +0000984 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000985 verifyFormat("var a = a.aaaaaaa(\n"
986 " (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000987 " aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000988 verifyFormat("var a = a.aaaaaaa(\n"
989 " (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000990 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
991 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000992
993 // FIXME: This is bad, we should be wrapping before "() => {".
994 verifyFormat("someFunction(() => {\n"
995 " doSomething(); // break\n"
996 "})\n"
997 " .doSomethingElse(\n"
998 " // break\n"
Martin Probst2c1cdae2017-05-15 11:15:29 +0000999 " );");
Martin Probstec363262017-08-01 17:19:32 +00001000 verifyFormat("const f = (x: string|null): string|null => {\n"
1001 " return x;\n"
1002 "}\n");
Manuel Klimek79e06082015-05-21 12:23:34 +00001003}
1004
Daniel Jasper166c19b2014-05-06 14:12:21 +00001005TEST_F(FormatTestJS, ReturnStatements) {
Daniel Jasper67f8ad22014-09-30 17:57:06 +00001006 verifyFormat("function() {\n"
1007 " return [hello, world];\n"
1008 "}");
Daniel Jasper166c19b2014-05-06 14:12:21 +00001009}
1010
Daniel Jasperf95b1f42015-11-20 16:18:42 +00001011TEST_F(FormatTestJS, ForLoops) {
1012 verifyFormat("for (var i in [2, 3]) {\n"
1013 "}");
Daniel Jasperb7fda112016-02-11 13:24:15 +00001014 verifyFormat("for (var i of [2, 3]) {\n"
1015 "}");
Daniel Jasperacffeb82016-03-05 18:34:26 +00001016 verifyFormat("for (let {a, b} of x) {\n"
1017 "}");
1018 verifyFormat("for (let {a, b} in x) {\n"
1019 "}");
Daniel Jasperf95b1f42015-11-20 16:18:42 +00001020}
1021
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001022TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
Daniel Jasper4c0bf702015-06-12 04:58:27 +00001023 // The following statements must not wrap, as otherwise the program meaning
1024 // would change due to automatic semicolon insertion.
1025 // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
1026 verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
Martin Probst56ff7aa2016-09-06 18:39:30 +00001027 verifyFormat("return /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
Daniel Jasper4c0bf702015-06-12 04:58:27 +00001028 verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
Martin Probst56ff7aa2016-09-06 18:39:30 +00001029 verifyFormat("continue /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
Daniel Jasper4c0bf702015-06-12 04:58:27 +00001030 verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
1031 verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
1032 verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
1033 verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
Daniel Jasper11a87652016-01-14 05:37:52 +00001034 verifyFormat("return [\n"
1035 " aaa\n"
1036 "];",
1037 getGoogleJSStyleWithColumns(12));
Martin Probsta81dd0b2017-07-07 13:17:10 +00001038 verifyFormat("class X {\n"
1039 " readonly ratherLongField =\n"
1040 " 1;\n"
1041 "}",
1042 "class X {\n"
1043 " readonly ratherLongField = 1;\n"
1044 "}",
1045 getGoogleJSStyleWithColumns(20));
Daniel Jasper4c0bf702015-06-12 04:58:27 +00001046}
1047
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001048TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
1049 verifyFormat("a\n"
1050 "b;",
1051 " a \n"
1052 " b ;");
1053 verifyFormat("a()\n"
1054 "b;",
1055 " a ()\n"
1056 " b ;");
1057 verifyFormat("a[b]\n"
1058 "c;",
1059 "a [b]\n"
1060 "c ;");
1061 verifyFormat("1\n"
1062 "a;",
1063 "1 \n"
1064 "a ;");
1065 verifyFormat("a\n"
1066 "1;",
1067 "a \n"
1068 "1 ;");
1069 verifyFormat("a\n"
1070 "'x';",
1071 "a \n"
1072 " 'x';");
1073 verifyFormat("a++\n"
1074 "b;",
1075 "a ++\n"
1076 "b ;");
1077 verifyFormat("a\n"
1078 "!b && c;",
1079 "a \n"
1080 " ! b && c;");
1081 verifyFormat("a\n"
1082 "if (1) f();",
1083 " a\n"
1084 " if (1) f();");
1085 verifyFormat("a\n"
1086 "class X {}",
1087 " a\n"
1088 " class X {}");
1089 verifyFormat("var a", "var\n"
1090 "a");
1091 verifyFormat("x instanceof String", "x\n"
1092 "instanceof\n"
1093 "String");
Martin Probstbbffeac2016-04-11 07:35:57 +00001094 verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
1095 " bar) {}");
Martin Probstb9316ff2016-09-18 17:21:52 +00001096 verifyFormat("a = true\n"
1097 "return 1",
1098 "a = true\n"
1099 " return 1");
1100 verifyFormat("a = 's'\n"
1101 "return 1",
1102 "a = 's'\n"
1103 " return 1");
1104 verifyFormat("a = null\n"
1105 "return 1",
1106 "a = null\n"
1107 " return 1");
Martin Probste6b5b342017-01-16 09:52:40 +00001108 // Below "class Y {}" should ideally be on its own line.
Martin Probstd40bca42017-01-09 08:56:36 +00001109 verifyFormat(
Martin Probstfd18ec52017-01-09 09:00:58 +00001110 "x = {\n"
1111 " a: 1\n"
Martin Probste6b5b342017-01-16 09:52:40 +00001112 "} class Y {}",
Martin Probstd40bca42017-01-09 08:56:36 +00001113 " x = {a : 1}\n"
1114 " class Y { }");
Martin Probste6b5b342017-01-16 09:52:40 +00001115 verifyFormat(
1116 "if (x) {\n"
1117 "}\n"
1118 "return 1",
1119 "if (x) {}\n"
1120 " return 1");
1121 verifyFormat(
1122 "if (x) {\n"
1123 "}\n"
1124 "class X {}",
1125 "if (x) {}\n"
1126 " class X {}");
Martin Probstd40bca42017-01-09 08:56:36 +00001127}
1128
1129TEST_F(FormatTestJS, ImportExportASI) {
1130 verifyFormat(
1131 "import {x} from 'y'\n"
1132 "export function z() {}",
1133 "import {x} from 'y'\n"
1134 " export function z() {}");
Martin Probste6b5b342017-01-16 09:52:40 +00001135 // Below "class Y {}" should ideally be on its own line.
Martin Probstd40bca42017-01-09 08:56:36 +00001136 verifyFormat(
Martin Probste6b5b342017-01-16 09:52:40 +00001137 "export {x} class Y {}",
Martin Probstd40bca42017-01-09 08:56:36 +00001138 " export {x}\n"
1139 " class Y {\n}");
Martin Probste6b5b342017-01-16 09:52:40 +00001140 verifyFormat(
1141 "if (x) {\n"
1142 "}\n"
1143 "export class Y {}",
1144 "if ( x ) { }\n"
1145 " export class Y {}");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001146}
1147
Manuel Klimek79e06082015-05-21 12:23:34 +00001148TEST_F(FormatTestJS, ClosureStyleCasts) {
Daniel Jasper484033b2014-05-06 14:41:29 +00001149 verifyFormat("var x = /** @type {foo} */ (bar);");
1150}
1151
Daniel Jasper04a71a42014-05-08 11:58:24 +00001152TEST_F(FormatTestJS, TryCatch) {
1153 verifyFormat("try {\n"
1154 " f();\n"
1155 "} catch (e) {\n"
1156 " g();\n"
1157 "} finally {\n"
1158 " h();\n"
1159 "}");
Daniel Jasper8f2e94c2014-09-04 15:03:34 +00001160
1161 // But, of course, "catch" is a perfectly fine function name in JavaScript.
1162 verifyFormat("someObject.catch();");
Daniel Jasper79121232014-11-27 14:55:17 +00001163 verifyFormat("someObject.new();");
1164 verifyFormat("someObject.delete();");
Daniel Jasper04a71a42014-05-08 11:58:24 +00001165}
1166
Daniel Jasper49802ef2014-05-22 09:10:04 +00001167TEST_F(FormatTestJS, StringLiteralConcatenation) {
1168 verifyFormat("var literal = 'hello ' +\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001169 " 'world';");
Daniel Jasper49802ef2014-05-22 09:10:04 +00001170}
1171
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001172TEST_F(FormatTestJS, RegexLiteralClassification) {
1173 // Regex literals.
1174 verifyFormat("var regex = /abc/;");
1175 verifyFormat("f(/abc/);");
1176 verifyFormat("f(abc, /abc/);");
1177 verifyFormat("some_map[/abc/];");
1178 verifyFormat("var x = a ? /abc/ : /abc/;");
1179 verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
1180 verifyFormat("var x = !/abc/.test(y);");
Martin Probst16282992017-02-07 14:08:03 +00001181 verifyFormat("var x = foo()! / 10;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001182 verifyFormat("var x = a && /abc/.test(y);");
1183 verifyFormat("var x = a || /abc/.test(y);");
1184 verifyFormat("var x = a + /abc/.search(y);");
Daniel Jasperc553ae12015-07-02 13:20:45 +00001185 verifyFormat("/abc/.search(y);");
Daniel Jasperf7405c12014-05-08 07:45:18 +00001186 verifyFormat("var regexs = {/abc/, /abc/};");
1187 verifyFormat("return /abc/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001188
1189 // Not regex literals.
1190 verifyFormat("var a = a / 2 + b / 3;");
Daniel Jasper265309e2015-10-18 07:02:28 +00001191 verifyFormat("var a = a++ / 2;");
1192 // Prefix unary can operate on regex literals, not that it makes sense.
1193 verifyFormat("var a = ++/a/;");
1194
1195 // This is a known issue, regular expressions are incorrectly detected if
1196 // directly following a closing parenthesis.
1197 verifyFormat("if (foo) / bar /.exec(baz);");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001198}
1199
1200TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
Daniel Jasper69694b02015-05-08 07:55:13 +00001201 verifyFormat("var regex = /=/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001202 verifyFormat("var regex = /a*/;");
1203 verifyFormat("var regex = /a+/;");
1204 verifyFormat("var regex = /a?/;");
1205 verifyFormat("var regex = /.a./;");
1206 verifyFormat("var regex = /a\\*/;");
1207 verifyFormat("var regex = /^a$/;");
1208 verifyFormat("var regex = /\\/a/;");
1209 verifyFormat("var regex = /(?:x)/;");
1210 verifyFormat("var regex = /x(?=y)/;");
1211 verifyFormat("var regex = /x(?!y)/;");
1212 verifyFormat("var regex = /x|y/;");
1213 verifyFormat("var regex = /a{2}/;");
1214 verifyFormat("var regex = /a{1,3}/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +00001215
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001216 verifyFormat("var regex = /[abc]/;");
1217 verifyFormat("var regex = /[^abc]/;");
1218 verifyFormat("var regex = /[\\b]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +00001219 verifyFormat("var regex = /[/]/;");
1220 verifyFormat("var regex = /[\\/]/;");
1221 verifyFormat("var regex = /\\[/;");
1222 verifyFormat("var regex = /\\\\[/]/;");
Daniel Jasper265309e2015-10-18 07:02:28 +00001223 verifyFormat("var regex = /}[\"]/;");
1224 verifyFormat("var regex = /}[/\"]/;");
1225 verifyFormat("var regex = /}[\"/]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +00001226
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001227 verifyFormat("var regex = /\\b/;");
1228 verifyFormat("var regex = /\\B/;");
1229 verifyFormat("var regex = /\\d/;");
1230 verifyFormat("var regex = /\\D/;");
1231 verifyFormat("var regex = /\\f/;");
1232 verifyFormat("var regex = /\\n/;");
1233 verifyFormat("var regex = /\\r/;");
1234 verifyFormat("var regex = /\\s/;");
1235 verifyFormat("var regex = /\\S/;");
1236 verifyFormat("var regex = /\\t/;");
1237 verifyFormat("var regex = /\\v/;");
1238 verifyFormat("var regex = /\\w/;");
1239 verifyFormat("var regex = /\\W/;");
1240 verifyFormat("var regex = /a(a)\\1/;");
1241 verifyFormat("var regex = /\\0/;");
Daniel Jasperfb4333b2014-05-12 11:29:50 +00001242 verifyFormat("var regex = /\\\\/g;");
1243 verifyFormat("var regex = /\\a\\\\/g;");
1244 verifyFormat("var regex = /\a\\//g;");
Daniel Jasper23376252014-09-09 14:37:39 +00001245 verifyFormat("var regex = /a\\//;\n"
1246 "var x = 0;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001247 verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
1248 verifyFormat("var regex = /'/g; //'", "var regex = /'/g ; //'");
1249 verifyFormat("var regex = /\\/*/;\n"
1250 "var x = 0;",
1251 "var regex = /\\/*/;\n"
1252 "var x=0;");
1253 verifyFormat("var x = /a\\//;", "var x = /a\\// \n;");
Daniel Jasper6b8d26c2015-06-24 16:01:02 +00001254 verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
1255 verifyFormat("var regex =\n"
1256 " /\"/;",
1257 getGoogleJSStyleWithColumns(15));
Daniel Jasperf7372152015-07-02 14:14:04 +00001258 verifyFormat("var regex = //\n"
1259 " /a/;");
Daniel Jasperf1446202015-07-02 15:00:44 +00001260 verifyFormat("var regexs = [\n"
1261 " /d/, //\n"
1262 " /aa/, //\n"
1263 "];");
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001264}
1265
1266TEST_F(FormatTestJS, RegexLiteralModifiers) {
1267 verifyFormat("var regex = /abc/g;");
1268 verifyFormat("var regex = /abc/i;");
1269 verifyFormat("var regex = /abc/m;");
1270 verifyFormat("var regex = /abc/y;");
1271}
1272
1273TEST_F(FormatTestJS, RegexLiteralLength) {
1274 verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1275 getGoogleJSStyleWithColumns(60));
1276 verifyFormat("var regex =\n"
1277 " /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1278 getGoogleJSStyleWithColumns(60));
Daniel Jasper0580ff02014-12-17 09:11:08 +00001279 verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1280 getGoogleJSStyleWithColumns(50));
Daniel Jasperf9ae3122014-05-08 07:01:45 +00001281}
1282
1283TEST_F(FormatTestJS, RegexLiteralExamples) {
1284 verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
1285}
1286
Martin Probstfa37b182017-01-27 09:09:11 +00001287TEST_F(FormatTestJS, IgnoresMpegTS) {
1288 std::string MpegTS(200, ' ');
1289 MpegTS.replace(0, strlen("nearlyLooks + like + ts + code; "),
1290 "nearlyLooks + like + ts + code; ");
1291 MpegTS[0] = 0x47;
1292 MpegTS[188] = 0x47;
1293 verifyFormat(MpegTS, MpegTS);
1294}
1295
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001296TEST_F(FormatTestJS, TypeAnnotations) {
1297 verifyFormat("var x: string;");
Daniel Jasperb9a49902016-01-09 15:56:28 +00001298 verifyFormat("var x: {a: string; b: number;} = {};");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001299 verifyFormat("function x(): string {\n return 'x';\n}");
Manuel Klimek79e06082015-05-21 12:23:34 +00001300 verifyFormat("function x(): {x: string} {\n return {x: 'x'};\n}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001301 verifyFormat("function x(y: string): string {\n return 'x';\n}");
1302 verifyFormat("for (var y: string in x) {\n x();\n}");
Daniel Jasperb7fda112016-02-11 13:24:15 +00001303 verifyFormat("for (var y: string of x) {\n x();\n}");
Daniel Jasperb9a49902016-01-09 15:56:28 +00001304 verifyFormat("function x(y: {a?: number;} = {}): number {\n"
1305 " return 12;\n"
1306 "}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001307 verifyFormat("((a: string, b: number): string => a + b);");
1308 verifyFormat("var x: (y: number) => string;");
1309 verifyFormat("var x: P<string, (a: number) => string>;");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +00001310 verifyFormat("var x = {\n"
1311 " y: function(): z {\n"
1312 " return 1;\n"
1313 " }\n"
1314 "};");
1315 verifyFormat("var x = {\n"
1316 " y: function(): {a: number} {\n"
1317 " return 1;\n"
1318 " }\n"
1319 "};");
Daniel Jasperf412e262016-01-08 10:51:24 +00001320 verifyFormat("function someFunc(args: string[]):\n"
1321 " {longReturnValue: string[]} {}",
1322 getGoogleJSStyleWithColumns(60));
Daniel Jasper3d934d32017-02-20 12:43:41 +00001323 verifyFormat(
1324 "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n"
1325 " .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
Daniel Jasperb10bdff2015-02-18 17:09:53 +00001326}
1327
Daniel Jasper91b1d1a2016-03-21 17:57:31 +00001328TEST_F(FormatTestJS, UnionIntersectionTypes) {
1329 verifyFormat("let x: A|B = A | B;");
1330 verifyFormat("let x: A&B|C = A & B;");
1331 verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
1332 verifyFormat("function(x: A|B): C&D {}");
1333 verifyFormat("function(x: A|B = A | B): C&D {}");
Martin Probst2ec23242016-06-09 22:49:04 +00001334 verifyFormat("function x(path: number|string) {}");
1335 verifyFormat("function x(): string|number {}");
Martin Probst1b7f9802016-06-23 19:52:32 +00001336 verifyFormat("type Foo = Bar|Baz;");
1337 verifyFormat("type Foo = Bar<X>|Baz;");
1338 verifyFormat("type Foo = (Bar<X>|Baz);");
1339 verifyFormat("let x: Bar|Baz;");
1340 verifyFormat("let x: Bar<X>|Baz;");
1341 verifyFormat("let x: (Foo|Bar)[];");
Martin Probstd96a0522017-06-07 12:53:22 +00001342 verifyFormat("type X = {\n"
1343 " a: Foo|Bar;\n"
1344 "};");
1345 verifyFormat("export type X = {\n"
1346 " a: Foo|Bar;\n"
1347 "};");
Daniel Jasper91b1d1a2016-03-21 17:57:31 +00001348}
1349
Daniel Jasper83709082015-02-18 17:14:05 +00001350TEST_F(FormatTestJS, ClassDeclarations) {
1351 verifyFormat("class C {\n x: string = 12;\n}");
1352 verifyFormat("class C {\n x(): string => 12;\n}");
1353 verifyFormat("class C {\n ['x' + 2]: string = 12;\n}");
Martin Probst95ed8e72017-05-31 09:29:40 +00001354 verifyFormat("class C {\n"
1355 " foo() {}\n"
1356 " [bar]() {}\n"
1357 "}\n");
Daniel Jasper83709082015-02-18 17:14:05 +00001358 verifyFormat("class C {\n private x: string = 12;\n}");
1359 verifyFormat("class C {\n private static x: string = 12;\n}");
Daniel Jasper28d8a5a2016-09-07 23:01:13 +00001360 verifyFormat("class C {\n static x(): string {\n return 'asd';\n }\n}");
Daniel Jasper83709082015-02-18 17:14:05 +00001361 verifyFormat("class C extends P implements I {}");
Daniel Jasper6a5d38d2015-04-13 14:56:54 +00001362 verifyFormat("class C extends p.P implements i.I {}");
Martin Probst1027fb82017-02-07 14:05:30 +00001363 verifyFormat(
1364 "x(class {\n"
1365 " a(): A {}\n"
1366 "});");
Daniel Jasperb9a52812015-07-10 13:39:26 +00001367 verifyFormat("class Test {\n"
1368 " aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
1369 " aaaaaaaaaaaaaaaaaaaaaa {}\n"
1370 "}");
Daniel Jasperd5ec65b2016-01-08 07:06:07 +00001371 verifyFormat("foo = class Name {\n"
1372 " constructor() {}\n"
1373 "};");
1374 verifyFormat("foo = class {\n"
1375 " constructor() {}\n"
1376 "};");
Daniel Jasperb9a49902016-01-09 15:56:28 +00001377 verifyFormat("class C {\n"
1378 " x: {y: Z;} = {};\n"
1379 " private y: {y: Z;} = {};\n"
1380 "}");
Daniel Jasper81dbb562015-06-03 08:43:18 +00001381
1382 // ':' is not a type declaration here.
1383 verifyFormat("class X {\n"
1384 " subs = {\n"
1385 " 'b': {\n"
1386 " 'c': 1,\n"
1387 " },\n"
1388 " };\n"
1389 "}");
Daniel Jasper64650082016-06-14 11:28:02 +00001390 verifyFormat("@Component({\n"
1391 " moduleId: module.id,\n"
1392 "})\n"
1393 "class SessionListComponent implements OnDestroy, OnInit {\n"
1394 "}");
Daniel Jasper83709082015-02-18 17:14:05 +00001395}
1396
Daniel Jasper29647492015-05-05 08:12:50 +00001397TEST_F(FormatTestJS, InterfaceDeclarations) {
1398 verifyFormat("interface I {\n"
1399 " x: string;\n"
Daniel Jasper6f5a1932015-12-29 08:54:23 +00001400 " enum: string[];\n"
Daniel Jasper87379302016-02-03 05:33:44 +00001401 " enum?: string[];\n"
Daniel Jasper259188b2015-06-12 04:56:34 +00001402 "}\n"
1403 "var y;");
Daniel Jasper5c235c02015-07-06 14:26:04 +00001404 // Ensure that state is reset after parsing the interface.
1405 verifyFormat("interface a {}\n"
1406 "export function b() {}\n"
1407 "var x;");
Daniel Jasperb542f9f2015-12-22 15:48:35 +00001408
1409 // Arrays of object type literals.
1410 verifyFormat("interface I {\n"
1411 " o: {}[];\n"
1412 "}");
Daniel Jasper29647492015-05-05 08:12:50 +00001413}
1414
Martin Probstcb870c52017-08-01 15:46:10 +00001415TEST_F(FormatTestJS, ObjectTypesInExtendsImplements) {
1416 verifyFormat("class C extends {} {}");
1417 verifyFormat("class C implements {bar: number} {}");
1418 // Somewhat odd, but probably closest to reasonable formatting?
1419 verifyFormat("class C implements {\n"
1420 " bar: number,\n"
1421 " baz: string,\n"
1422 "} {}");
1423 verifyFormat("class C<P extends {}> {}");
1424}
1425
Daniel Jasper90cf3802015-06-17 09:44:02 +00001426TEST_F(FormatTestJS, EnumDeclarations) {
1427 verifyFormat("enum Foo {\n"
Daniel Jasper9f4ec152015-06-17 09:44:07 +00001428 " A = 1,\n"
1429 " B\n"
1430 "}");
1431 verifyFormat("export /* somecomment*/ enum Foo {\n"
1432 " A = 1,\n"
1433 " B\n"
1434 "}");
1435 verifyFormat("enum Foo {\n"
Daniel Jasper90cf3802015-06-17 09:44:02 +00001436 " A = 1, // comment\n"
1437 " B\n"
1438 "}\n"
1439 "var x = 1;");
Martin Probstdb51cc52017-08-01 17:12:15 +00001440 verifyFormat("const enum Foo {\n"
1441 " A = 1,\n"
1442 " B\n"
1443 "}");
1444 verifyFormat("export const enum Foo {\n"
1445 " A = 1,\n"
1446 " B\n"
1447 "}");
Daniel Jasper90cf3802015-06-17 09:44:02 +00001448}
1449
Daniel Jasper3c42dba2015-02-18 17:17:15 +00001450TEST_F(FormatTestJS, MetadataAnnotations) {
1451 verifyFormat("@A\nclass C {\n}");
1452 verifyFormat("@A({arg: 'value'})\nclass C {\n}");
1453 verifyFormat("@A\n@B\nclass C {\n}");
1454 verifyFormat("class C {\n @A x: string;\n}");
1455 verifyFormat("class C {\n"
1456 " @A\n"
1457 " private x(): string {\n"
1458 " return 'y';\n"
1459 " }\n"
1460 "}");
Martin Probst716a5332016-04-11 09:17:57 +00001461 verifyFormat("class C {\n"
1462 " private x(@A x: string) {}\n"
1463 "}");
Daniel Jasper6fa9ec72015-02-19 16:03:16 +00001464 verifyFormat("class X {}\n"
1465 "class Y {}");
Martin Probstad063912017-04-26 12:36:49 +00001466 verifyFormat("class X {\n"
1467 " @property() private isReply = false;\n"
1468 "}\n");
Daniel Jasper3c42dba2015-02-18 17:17:15 +00001469}
1470
Martin Probst805c6162016-04-19 14:59:16 +00001471TEST_F(FormatTestJS, TypeAliases) {
1472 verifyFormat("type X = number;\n"
1473 "class C {}");
1474 verifyFormat("type X<Y> = Z<Y>;");
1475 verifyFormat("type X = {\n"
1476 " y: number\n"
1477 "};\n"
1478 "class C {}");
1479}
1480
Martin Probstb98ab892017-03-13 07:10:18 +00001481TEST_F(FormatTestJS, TypeInterfaceLineWrapping) {
1482 const FormatStyle &Style = getGoogleJSStyleWithColumns(20);
1483 verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n"
1484 " string;\n",
1485 "type LongTypeIsReallyUnreasonablyLong = string;\n",
1486 Style);
1487 verifyFormat(
1488 "interface AbstractStrategyFactoryProvider {\n"
1489 " a: number\n"
1490 "}\n",
1491 "interface AbstractStrategyFactoryProvider { a: number }\n",
1492 Style);
1493}
1494
Daniel Jasper354aa512015-02-19 16:07:32 +00001495TEST_F(FormatTestJS, Modules) {
1496 verifyFormat("import SomeThing from 'some/module.js';");
1497 verifyFormat("import {X, Y} from 'some/module.js';");
Daniel Jasperefc1a832016-01-07 08:53:35 +00001498 verifyFormat("import a, {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001499 verifyFormat("import {X, Y,} from 'some/module.js';");
Daniel Jasper354aa512015-02-19 16:07:32 +00001500 verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
Martin Probst48622092016-06-01 15:22:47 +00001501 // Ensure Automatic Semicolon Insertion does not break on "as\n".
1502 verifyFormat("import {X as myX} from 'm';", "import {X as\n"
1503 " myX} from 'm';");
Daniel Jasper354aa512015-02-19 16:07:32 +00001504 verifyFormat("import * as lib from 'some/module.js';");
Daniel Jasper60948b12015-03-15 13:55:54 +00001505 verifyFormat("var x = {import: 1};\nx.import = 2;");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001506
1507 verifyFormat("export function fn() {\n"
1508 " return 'fn';\n"
1509 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001510 verifyFormat("export function A() {}\n"
1511 "export default function B() {}\n"
1512 "export function C() {}");
Martin Probst053f1aa2016-04-19 14:55:37 +00001513 verifyFormat("export default () => {\n"
1514 " let x = 1;\n"
1515 " return x;\n"
1516 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001517 verifyFormat("export const x = 12;");
1518 verifyFormat("export default class X {}");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001519 verifyFormat("export {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001520 verifyFormat("export {X, Y,} from 'some/module.js';");
1521 verifyFormat("export {SomeVeryLongExport as X, "
1522 "SomeOtherVeryLongExport as Y} from 'some/module.js';");
1523 // export without 'from' is wrapped.
1524 verifyFormat("export let someRatherLongVariableName =\n"
1525 " someSurprisinglyLongVariable + someOtherRatherLongVar;");
1526 // ... but not if from is just an identifier.
Daniel Jasperfca735c2015-02-19 16:14:18 +00001527 verifyFormat("export {\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001528 " from as from,\n"
Martin Probstdce8e412016-06-22 14:35:14 +00001529 " someSurprisinglyLongVariable as\n"
1530 " from\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +00001531 "};",
1532 getGoogleJSStyleWithColumns(20));
Daniel Jasperfca735c2015-02-19 16:14:18 +00001533 verifyFormat("export class C {\n"
1534 " x: number;\n"
1535 " y: string;\n"
1536 "}");
1537 verifyFormat("export class X { y: number; }");
Daniel Jasper8620d4c2016-01-12 06:24:38 +00001538 verifyFormat("export abstract class X { y: number; }");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001539 verifyFormat("export default class X { y: number }");
1540 verifyFormat("export default function() {\n return 1;\n}");
1541 verifyFormat("export var x = 12;");
Daniel Jasper910807d2015-06-12 04:52:02 +00001542 verifyFormat("class C {}\n"
1543 "export function f() {}\n"
1544 "var v;");
Daniel Jasperfca735c2015-02-19 16:14:18 +00001545 verifyFormat("export var x: number = 12;");
1546 verifyFormat("export const y = {\n"
1547 " a: 1,\n"
1548 " b: 2\n"
1549 "};");
Daniel Jasper216c9cd2015-06-12 05:08:18 +00001550 verifyFormat("export enum Foo {\n"
1551 " BAR,\n"
1552 " // adsdasd\n"
1553 " BAZ\n"
1554 "}");
Daniel Jasperb14f6672016-01-04 15:51:56 +00001555 verifyFormat("export default [\n"
1556 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1557 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
1558 "];");
1559 verifyFormat("export default [];");
Daniel Jasper5e271462016-01-04 16:10:36 +00001560 verifyFormat("export default () => {};");
Daniel Jasperf55e4182016-01-11 22:57:40 +00001561 verifyFormat("export interface Foo { foo: number; }\n"
1562 "export class Bar {\n"
Daniel Jasper28d8a5a2016-09-07 23:01:13 +00001563 " blah(): string {\n"
1564 " return this.blah;\n"
1565 " };\n"
Daniel Jasperf55e4182016-01-11 22:57:40 +00001566 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001567}
1568
Martin Probst0cd74ee2016-06-13 16:39:50 +00001569TEST_F(FormatTestJS, ImportWrapping) {
1570 verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
1571 " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
1572 "} from 'some/module.js';");
1573 FormatStyle Style = getGoogleJSStyleWithColumns(80);
1574 Style.JavaScriptWrapImports = true;
1575 verifyFormat("import {\n"
1576 " VeryLongImportsAreAnnoying,\n"
1577 " VeryLongImportsAreAnnoying,\n"
1578 " VeryLongImportsAreAnnoying,\n"
1579 "} from 'some/module.js';",
1580 Style);
1581 verifyFormat("import {\n"
1582 " A,\n"
1583 " A,\n"
1584 "} from 'some/module.js';",
1585 Style);
1586 verifyFormat("export {\n"
1587 " A,\n"
1588 " A,\n"
1589 "} from 'some/module.js';",
1590 Style);
Martin Probst93008f02017-07-18 14:00:19 +00001591 Style.ColumnLimit = 40;
1592 // Using this version of verifyFormat because test::messUp hides the issue.
1593 verifyFormat("import {\n"
1594 " A,\n"
1595 "} from\n"
1596 " 'some/path/longer/than/column/limit/module.js';",
1597 " import { \n"
1598 " A, \n"
1599 " } from\n"
1600 " 'some/path/longer/than/column/limit/module.js' ; ",
1601 Style);
Martin Probst0cd74ee2016-06-13 16:39:50 +00001602}
1603
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001604TEST_F(FormatTestJS, TemplateStrings) {
1605 // Keeps any whitespace/indentation within the template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001606 verifyFormat("var x = `hello\n"
Martin Probst6181da42016-08-25 10:13:21 +00001607 " ${name}\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001608 " !`;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001609 "var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001610 " ${ name }\n"
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001611 " !`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001612
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001613 verifyFormat("var x =\n"
1614 " `hello ${world}` >= some();",
1615 getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
1616 verifyFormat("var x = `hello ${world}` >= some();",
Daniel Jasper553a5b02015-07-02 13:08:28 +00001617 getGoogleJSStyleWithColumns(35)); // Barely fits.
Martin Probste71b4cb2016-05-17 06:29:29 +00001618 verifyFormat("var x = `hellö ${wörld}` >= söme();",
1619 getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001620 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001621 " ${world}` >=\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001622 " some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001623 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001624 " `hello\n"
1625 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001626 getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
1627 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001628 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001629 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001630 " `hello\n"
1631 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001632 getGoogleJSStyleWithColumns(22)); // Barely fits.
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001633
Daniel Jasper553a5b02015-07-02 13:08:28 +00001634 verifyFormat("var x =\n"
1635 " `h`;",
1636 getGoogleJSStyleWithColumns(11));
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001637 verifyFormat("var x =\n `multi\n line`;", "var x = `multi\n line`;",
1638 getGoogleJSStyleWithColumns(13));
Daniel Jasper553a5b02015-07-02 13:08:28 +00001639 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1640 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
Martin Probste71b4cb2016-05-17 06:29:29 +00001641 // Repro for an obscure width-miscounting issue with template strings.
1642 verifyFormat(
1643 "someLongVariable =\n"
1644 " "
1645 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;",
1646 "someLongVariable = "
1647 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001648
Daniel Jasperf69b9222015-05-02 08:05:38 +00001649 // Make sure template strings get a proper ColumnWidth assigned, even if they
1650 // are first token in line.
1651 verifyFormat(
1652 "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001653 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
Daniel Jasperf69b9222015-05-02 08:05:38 +00001654
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001655 // Two template strings.
1656 verifyFormat("var x = `hello` == `hello`;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001657
1658 // Comments in template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001659 verifyFormat("var x = `//a`;\n"
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001660 "var y;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001661 "var x =\n `//a`;\n"
1662 "var y ;");
1663 verifyFormat("var x = `/*a`;\n"
1664 "var y;",
1665 "var x =\n `/*a`;\n"
1666 "var y;");
Daniel Jasper2ebb0c52015-06-14 07:16:57 +00001667 // Unterminated string literals in a template string.
1668 verifyFormat("var x = `'`; // comment with matching quote '\n"
1669 "var y;");
1670 verifyFormat("var x = `\"`; // comment with matching quote \"\n"
1671 "var y;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001672 verifyFormat("it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa);",
1673 "it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa) ;",
1674 getGoogleJSStyleWithColumns(40));
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001675 // Backticks in a comment - not a template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001676 verifyFormat("var x = 1 // `/*a`;\n"
1677 " ;",
1678 "var x =\n 1 // `/*a`;\n"
1679 " ;");
1680 verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001681 // Comment spans multiple template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001682 verifyFormat("var x = `/*a`;\n"
1683 "var y = ` */ `;",
1684 "var x =\n `/*a`;\n"
1685 "var y =\n ` */ `;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001686 // Escaped backtick.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001687 verifyFormat("var x = ` \\` a`;\n"
1688 "var y;",
1689 "var x = ` \\` a`;\n"
1690 "var y;");
Martin Probst6181da42016-08-25 10:13:21 +00001691 // Escaped dollar.
1692 verifyFormat("var x = ` \\${foo}`;\n");
Daniel Jasperf2019292017-01-31 12:07:35 +00001693
1694 // The token stream can contain two string_literals in sequence, but that
1695 // doesn't mean that they are implicitly concatenated in JavaScript.
1696 verifyFormat("var f = `aaaa ${a ? 'a' : 'b'}`;");
Daniel Jasper24de6fb2017-01-31 13:03:07 +00001697
1698 // Ensure that scopes are appropriately set around evaluated expressions in
1699 // template strings.
1700 verifyFormat("var f = `aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa\n"
1701 " aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`;",
1702 "var f = `aaaaaaaaaaaaa:${aaaaaaa. aaaaa} aaaaaaaa\n"
1703 " aaaaaaaaaaaaa:${ aaaaaaa. aaaaa} aaaaaaaa`;");
Daniel Jasperc06f6da2017-02-03 14:32:38 +00001704 verifyFormat("var x = someFunction(`${})`) //\n"
1705 " .oooooooooooooooooon();");
Daniel Jasper98e0b122017-02-20 14:51:16 +00001706 verifyFormat("var x = someFunction(`${aaaa}${\n"
1707 " aaaaa( //\n"
1708 " aaaaa)\n"
1709 " })`);");
Martin Probst6181da42016-08-25 10:13:21 +00001710}
1711
Daniel Jasper3f119412017-01-31 14:39:33 +00001712TEST_F(FormatTestJS, TemplateStringMultiLineExpression) {
Daniel Jasper98e0b122017-02-20 14:51:16 +00001713 verifyFormat("var f = `aaaaaaaaaaaaaaaaaa: ${\n"
1714 " aaaaa + //\n"
1715 " bbbb\n"
1716 " }`;",
Daniel Jasper3f119412017-01-31 14:39:33 +00001717 "var f = `aaaaaaaaaaaaaaaaaa: ${aaaaa + //\n"
1718 " bbbb}`;");
Daniel Jasper3f119412017-01-31 14:39:33 +00001719 verifyFormat("var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001720 " aaaaaaaaaaaaaaaaaa: ${\n"
1721 " aaaaa + //\n"
1722 " bbbb\n"
1723 " }`;",
Daniel Jasper3f119412017-01-31 14:39:33 +00001724 "var f = `\n"
1725 " aaaaaaaaaaaaaaaaaa: ${ aaaaa + //\n"
1726 " bbbb }`;");
1727 verifyFormat("var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001728 " aaaaaaaaaaaaaaaaaa: ${\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001729 " someFunction(\n"
1730 " aaaaa + //\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001731 " bbbb)\n"
1732 " }`;",
Daniel Jasper3f119412017-01-31 14:39:33 +00001733 "var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001734 " aaaaaaaaaaaaaaaaaa: ${someFunction (\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001735 " aaaaa + //\n"
1736 " bbbb)}`;");
Daniel Jasper98e0b122017-02-20 14:51:16 +00001737
1738 // It might be preferable to wrap before "someFunction".
Daniel Jasper3f119412017-01-31 14:39:33 +00001739 verifyFormat("var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001740 " aaaaaaaaaaaaaaaaaa: ${someFunction({\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001741 " aaaa: aaaaa,\n"
1742 " bbbb: bbbbb,\n"
1743 " })}`;",
1744 "var f = `\n"
Daniel Jasper98e0b122017-02-20 14:51:16 +00001745 " aaaaaaaaaaaaaaaaaa: ${someFunction ({\n"
Daniel Jasper3f119412017-01-31 14:39:33 +00001746 " aaaa: aaaaa,\n"
1747 " bbbb: bbbbb,\n"
1748 " })}`;");
1749}
1750
Martin Probst717f6dc2016-10-21 05:11:38 +00001751TEST_F(FormatTestJS, TemplateStringASI) {
1752 verifyFormat("var x = `hello${world}`;", "var x = `hello${\n"
1753 " world\n"
1754 "}`;");
1755}
1756
Martin Probst6181da42016-08-25 10:13:21 +00001757TEST_F(FormatTestJS, NestedTemplateStrings) {
1758 verifyFormat(
1759 "var x = `<ul>${xs.map(x => `<li>${x}</li>`).join('\\n')}</ul>`;");
1760 verifyFormat("var x = `he${({text: 'll'}.text)}o`;");
Daniel Jasper58209dd2016-09-17 07:20:36 +00001761
1762 // Crashed at some point.
1763 verifyFormat("}");
Martin Probst6181da42016-08-25 10:13:21 +00001764}
1765
1766TEST_F(FormatTestJS, TaggedTemplateStrings) {
1767 verifyFormat("var x = html`<ul>`;");
Martin Probst37a7f912017-07-04 15:30:21 +00001768 verifyFormat("yield `hello`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001769}
1770
Martin Probst805c6162016-04-19 14:59:16 +00001771TEST_F(FormatTestJS, CastSyntax) {
1772 verifyFormat("var x = <type>foo;");
1773 verifyFormat("var x = foo as type;");
Martin Probstdce8e412016-06-22 14:35:14 +00001774 verifyFormat("let x = (a + b) as\n"
1775 " LongTypeIsLong;",
1776 getGoogleJSStyleWithColumns(20));
Daniel Jasper887a3992016-06-14 13:54:38 +00001777 verifyFormat("foo = <Bar[]>[\n"
1778 " 1, //\n"
1779 " 2\n"
1780 "];");
Martin Probste1e12a72016-08-19 14:35:01 +00001781 verifyFormat("var x = [{x: 1} as type];");
Martin Probsted87d782016-08-22 14:23:30 +00001782 verifyFormat("x = x as [a, b];");
1783 verifyFormat("x = x as {a: string};");
1784 verifyFormat("x = x as (string);");
Martin Probst34ecf422016-09-06 18:55:34 +00001785 verifyFormat("x = x! as (string);");
Daniel Jasper01b87832017-03-01 19:26:12 +00001786 verifyFormat("var x = something.someFunction() as\n"
1787 " something;",
1788 getGoogleJSStyleWithColumns(40));
Martin Probst805c6162016-04-19 14:59:16 +00001789}
Daniel Jasperbc46b932015-03-15 13:59:51 +00001790
1791TEST_F(FormatTestJS, TypeArguments) {
1792 verifyFormat("class X<Y> {}");
1793 verifyFormat("new X<Y>();");
1794 verifyFormat("foo<Y>(a);");
1795 verifyFormat("var x: X<Y>[];");
1796 verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001797 verifyFormat("function f(a: List<any> = null) {}");
1798 verifyFormat("function f(): List<any> {}");
Daniel Jasper5a3de1d2015-07-03 10:37:23 +00001799 verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1800 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001801 verifyFormat("function aaaaaaaaaa(\n"
1802 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1803 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
Daniel Jasperb2328b12015-07-06 14:07:51 +00001804 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
Daniel Jasperbc46b932015-03-15 13:59:51 +00001805}
1806
Daniel Jasper779c66f2015-12-30 08:00:58 +00001807TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1808 verifyFormat(
1809 "function foo(check: Object):\n"
1810 " check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1811 " return 'bar' in check;\n"
1812 "}\n");
1813}
1814
Daniel Jaspera74f5072015-04-13 15:01:40 +00001815TEST_F(FormatTestJS, OptionalTypes) {
Daniel Jasper20580fd2015-06-11 13:31:45 +00001816 verifyFormat("function x(a?: b, c?, d?) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001817 verifyFormat("class X {\n"
1818 " y?: z;\n"
1819 " z?;\n"
1820 "}");
Daniel Jasper9326f912015-05-05 08:40:32 +00001821 verifyFormat("interface X {\n"
1822 " y?(): z;\n"
1823 "}");
Daniel Jasper3e0dcc22015-05-27 05:37:40 +00001824 verifyFormat("constructor({aa}: {\n"
1825 " aa?: string,\n"
1826 " aaaaaaaa?: string,\n"
1827 " aaaaaaaaaaaaaaa?: boolean,\n"
1828 " aaaaaa?: List<string>\n"
Daniel Jasper20580fd2015-06-11 13:31:45 +00001829 "}) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001830}
1831
Daniel Jasperd9309772015-04-13 15:03:30 +00001832TEST_F(FormatTestJS, IndexSignature) {
1833 verifyFormat("var x: {[k: string]: v};");
1834}
1835
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001836TEST_F(FormatTestJS, WrapAfterParen) {
1837 verifyFormat("xxxxxxxxxxx(\n"
1838 " aaa, aaa);",
1839 getGoogleJSStyleWithColumns(20));
1840 verifyFormat("xxxxxxxxxxx(\n"
1841 " aaa, aaa, aaa,\n"
1842 " aaa, aaa, aaa);",
1843 getGoogleJSStyleWithColumns(20));
1844 verifyFormat("xxxxxxxxxxx(\n"
1845 " aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1846 " function(x) {\n"
1847 " y(); //\n"
1848 " });",
1849 getGoogleJSStyleWithColumns(40));
1850 verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1851 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1852}
1853
Daniel Jasperd196abb2016-01-08 08:14:58 +00001854TEST_F(FormatTestJS, JSDocAnnotations) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001855 verifyFormat("/**\n"
1856 " * @export {this.is.a.long.path.to.a.Type}\n"
1857 " */",
1858 "/**\n"
1859 " * @export {this.is.a.long.path.to.a.Type}\n"
1860 " */",
1861 getGoogleJSStyleWithColumns(20));
Martin Probstbb46a7d2017-02-28 11:08:24 +00001862 verifyFormat("/**\n"
1863 " * @mods {this.is.a.long.path.to.a.Type}\n"
1864 " */",
1865 "/**\n"
1866 " * @mods {this.is.a.long.path.to.a.Type}\n"
1867 " */",
1868 getGoogleJSStyleWithColumns(20));
1869 verifyFormat("/**\n"
1870 " * @param {this.is.a.long.path.to.a.Type}\n"
1871 " */",
1872 "/**\n"
1873 " * @param {this.is.a.long.path.to.a.Type}\n"
1874 " */",
1875 getGoogleJSStyleWithColumns(20));
Martin Probstb4cdb652017-03-13 09:39:23 +00001876 verifyFormat("/**\n"
1877 " * @see http://very/very/long/url/is/long\n"
1878 " */",
1879 "/**\n"
1880 " * @see http://very/very/long/url/is/long\n"
1881 " */",
1882 getGoogleJSStyleWithColumns(20));
Martin Probstbb46a7d2017-02-28 11:08:24 +00001883 verifyFormat(
1884 "/**\n"
1885 " * @param This is a\n"
1886 " * long comment but\n"
1887 " * no type\n"
1888 " */",
1889 "/**\n"
1890 " * @param This is a long comment but no type\n"
1891 " */",
1892 getGoogleJSStyleWithColumns(20));
Krasimir Georgiev17725d82017-03-08 08:55:12 +00001893 // Don't break @param line, but reindent it and reflow unrelated lines.
1894 verifyFormat("{\n"
1895 " /**\n"
1896 " * long long long\n"
1897 " * long\n"
1898 " * @param {this.is.a.long.path.to.a.Type} a\n"
1899 " * long long long\n"
1900 " * long long\n"
1901 " */\n"
1902 " function f(a) {}\n"
1903 "}",
1904 "{\n"
1905 "/**\n"
1906 " * long long long long\n"
1907 " * @param {this.is.a.long.path.to.a.Type} a\n"
1908 " * long long long long\n"
1909 " * long\n"
1910 " */\n"
1911 " function f(a) {}\n"
1912 "}",
1913 getGoogleJSStyleWithColumns(20));
Daniel Jasperd196abb2016-01-08 08:14:58 +00001914}
1915
Daniel Jasperabd1f572016-03-02 22:44:03 +00001916TEST_F(FormatTestJS, RequoteStringsSingle) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001917 verifyFormat("var x = 'foo';", "var x = \"foo\";");
1918 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
1919 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
1920 verifyFormat(
1921 "var x =\n"
1922 " 'foo\\'';",
1923 // Code below is 15 chars wide, doesn't fit into the line with the
1924 // \ escape added.
1925 "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
Daniel Jasperabd1f572016-03-02 22:44:03 +00001926 // Removes no-longer needed \ escape from ".
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001927 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001928 // Code below fits into 15 chars *after* removing the \ escape.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001929 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
1930 getGoogleJSStyleWithColumns(15));
Martin Probsta1669792016-05-12 11:20:32 +00001931 verifyFormat("// clang-format off\n"
1932 "let x = \"double\";\n"
1933 "// clang-format on\n"
1934 "let x = 'single';\n",
1935 "// clang-format off\n"
1936 "let x = \"double\";\n"
1937 "// clang-format on\n"
1938 "let x = \"single\";\n");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001939}
1940
Martin Probsta9855af2016-09-02 14:29:48 +00001941TEST_F(FormatTestJS, RequoteAndIndent) {
1942 verifyFormat("let x = someVeryLongFunctionThatGoesOnAndOn(\n"
1943 " 'double quoted string that needs wrapping');",
1944 "let x = someVeryLongFunctionThatGoesOnAndOn("
1945 "\"double quoted string that needs wrapping\");");
Daniel Jasper496c1992016-09-07 22:48:53 +00001946
1947 verifyFormat("let x =\n"
1948 " 'foo\\'oo';\n"
1949 "let x =\n"
1950 " 'foo\\'oo';",
1951 "let x=\"foo'oo\";\n"
1952 "let x=\"foo'oo\";",
1953 getGoogleJSStyleWithColumns(15));
Martin Probsta9855af2016-09-02 14:29:48 +00001954}
1955
Daniel Jasperabd1f572016-03-02 22:44:03 +00001956TEST_F(FormatTestJS, RequoteStringsDouble) {
1957 FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1958 DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
1959 verifyFormat("var x = \"foo\";", DoubleQuotes);
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001960 verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
1961 verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
Daniel Jasperabd1f572016-03-02 22:44:03 +00001962}
1963
1964TEST_F(FormatTestJS, RequoteStringsLeave) {
1965 FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1966 LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
1967 verifyFormat("var x = \"foo\";", LeaveQuotes);
1968 verifyFormat("var x = 'foo';", LeaveQuotes);
1969}
1970
Martin Probst7ea9b6d2016-05-29 14:41:36 +00001971TEST_F(FormatTestJS, SupportShebangLines) {
1972 verifyFormat("#!/usr/bin/env node\n"
1973 "var x = hello();",
1974 "#!/usr/bin/env node\n"
1975 "var x = hello();");
1976}
1977
Martin Probst0eb40cf2016-06-13 00:49:54 +00001978TEST_F(FormatTestJS, NonNullAssertionOperator) {
1979 verifyFormat("let x = foo!.bar();\n");
1980 verifyFormat("let x = foo ? bar! : baz;\n");
1981 verifyFormat("let x = !foo;\n");
1982 verifyFormat("let x = foo[0]!;\n");
1983 verifyFormat("let x = (foo)!;\n");
Martin Probstab60acb2017-05-22 14:58:26 +00001984 verifyFormat("let x = x(foo!);\n");
1985 verifyFormat(
1986 "a.aaaaaa(a.a!).then(\n"
1987 " x => x(x));\n",
1988 getGoogleJSStyleWithColumns(20));
Daniel Jasper8315ea12016-11-09 14:12:55 +00001989 verifyFormat("let x = foo! - 1;\n");
Martin Probst0eb40cf2016-06-13 00:49:54 +00001990 verifyFormat("let x = {foo: 1}!;\n");
Martin Probst22b8d2692017-03-13 09:14:23 +00001991 verifyFormat(
1992 "let x = hello.foo()!\n"
1993 " .foo()!\n"
1994 " .foo()!\n"
1995 " .foo()!;\n",
1996 getGoogleJSStyleWithColumns(20));
Martin Probst79f9c5f2017-05-12 13:00:33 +00001997 verifyFormat("let x = namespace!;\n");
Martin Probst82b3d902017-05-15 08:15:53 +00001998 verifyFormat("return !!x;\n");
Martin Probst0eb40cf2016-06-13 00:49:54 +00001999}
2000
Martin Probst31d6da72016-06-23 21:51:49 +00002001TEST_F(FormatTestJS, Conditional) {
2002 verifyFormat("y = x ? 1 : 2;");
Daniel Jasperd9d8da22016-07-12 15:45:53 +00002003 verifyFormat("x ? 1 : 2;");
Martin Probst31d6da72016-06-23 21:51:49 +00002004 verifyFormat("class Foo {\n"
2005 " field = true ? 1 : 2;\n"
2006 " method(a = true ? 1 : 2) {}\n"
2007 "}");
2008}
2009
Martin Probstfbbe75b2016-09-18 17:33:51 +00002010TEST_F(FormatTestJS, ImportComments) {
2011 verifyFormat("import {x} from 'x'; // from some location",
2012 getGoogleJSStyleWithColumns(25));
2013 verifyFormat("// taze: x from 'location'", getGoogleJSStyleWithColumns(10));
Martin Probst2083f312017-05-09 12:45:48 +00002014 verifyFormat("/// <reference path=\"some/location\" />", getGoogleJSStyleWithColumns(10));
Martin Probstfbbe75b2016-09-18 17:33:51 +00002015}
Martin Probst4ef03702017-05-04 15:04:04 +00002016
2017TEST_F(FormatTestJS, Exponentiation) {
2018 verifyFormat("squared = x ** 2;");
2019 verifyFormat("squared **= 2;");
2020}
2021
Martin Probst38423272017-06-06 12:38:29 +00002022TEST_F(FormatTestJS, NestedLiterals) {
2023 FormatStyle FourSpaces = getGoogleJSStyleWithColumns(15);
2024 FourSpaces.IndentWidth = 4;
2025 verifyFormat("var l = [\n"
2026 " [\n"
2027 " 1,\n"
2028 " ],\n"
2029 "];", FourSpaces);
2030 verifyFormat("var l = [\n"
2031 " {\n"
2032 " 1: 1,\n"
2033 " },\n"
2034 "];", FourSpaces);
2035 verifyFormat("someFunction(\n"
2036 " p1,\n"
2037 " [\n"
2038 " 1,\n"
2039 " ],\n"
2040 ");", FourSpaces);
2041 verifyFormat("someFunction(\n"
2042 " p1,\n"
2043 " {\n"
2044 " 1: 1,\n"
2045 " },\n"
2046 ");", FourSpaces);
2047 verifyFormat("var o = {\n"
2048 " 1: 1,\n"
2049 " 2: {\n"
2050 " 3: 3,\n"
2051 " },\n"
2052 "};", FourSpaces);
2053 verifyFormat("var o = {\n"
2054 " 1: 1,\n"
2055 " 2: [\n"
2056 " 3,\n"
2057 " ],\n"
2058 "};", FourSpaces);
2059}
2060
Alexander Kornienkoab9db512015-06-22 23:07:51 +00002061} // end namespace tooling
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00002062} // end namespace clang