blob: 9be375243c810f73c7ea734c97852ddef9a03bb6 [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));
Daniel Jasper56691b82015-06-11 13:29:20 +000027 bool IncompleteFormat = false;
28 tooling::Replacements Replaces =
29 reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
30 EXPECT_FALSE(IncompleteFormat);
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000031 std::string Result = applyAllReplacements(Code, Replaces);
32 EXPECT_NE("", Result);
33 DEBUG(llvm::errs() << "\n" << Result << "\n\n");
34 return Result;
35 }
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 Jasper6501f7e2015-10-27 12:38:37 +000052 std::string result = format(test::messUp(Code), Style);
53 EXPECT_EQ(Code.str(), result) << "Formatted:\n" << result;
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000054 }
55};
56
57TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
58 verifyFormat("a == = b;");
59 verifyFormat("a != = b;");
60
61 verifyFormat("a === b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000062 verifyFormat("aaaaaaa ===\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000063 verifyFormat("a !== b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000064 verifyFormat("aaaaaaa !==\n b;", getGoogleJSStyleWithColumns(10));
65 verifyFormat("if (a + b + c +\n"
66 " d !==\n"
67 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000068 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000069 getGoogleJSStyleWithColumns(20));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000070
71 verifyFormat("a >> >= b;");
72
73 verifyFormat("a >>> b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000074 verifyFormat("aaaaaaa >>>\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000075 verifyFormat("a >>>= b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000076 verifyFormat("aaaaaaa >>>=\n b;", getGoogleJSStyleWithColumns(10));
77 verifyFormat("if (a + b + c +\n"
78 " d >>>\n"
79 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000080 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000081 getGoogleJSStyleWithColumns(20));
Daniel Jaspere551bb72014-11-05 17:22:31 +000082 verifyFormat("var x = aaaaaaaaaa ?\n"
83 " bbbbbb :\n"
84 " ccc;",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000085 getGoogleJSStyleWithColumns(20));
Daniel Jasper78214392014-05-19 07:27:02 +000086
87 verifyFormat("var b = a.map((x) => x + 1);");
Daniel Jasper3549ea12014-09-19 10:48:15 +000088 verifyFormat("return ('aaa') in bbbb;");
Daniel Jasper08051992015-05-26 07:18:56 +000089
90 // ES6 spread operator.
91 verifyFormat("someFunction(...a);");
92 verifyFormat("var x = [1, ...a, 2];");
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000093}
94
Daniel Jasper3a038de2014-09-05 08:53:45 +000095TEST_F(FormatTestJS, UnderstandsAmpAmp) {
96 verifyFormat("e && e.SomeFunction();");
97}
98
Daniel Jasper4db69bd2014-09-04 18:23:42 +000099TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
100 verifyFormat("not.and.or.not_eq = 1;");
101}
102
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000103TEST_F(FormatTestJS, ReservedWords) {
104 // JavaScript reserved words (aka keywords) are only illegal when used as
105 // Identifiers, but are legal as IdentifierNames.
106 verifyFormat("x.class.struct = 1;");
107 verifyFormat("x.case = 1;");
108 verifyFormat("x.interface = 1;");
109 verifyFormat("x = {\n"
110 " a: 12,\n"
111 " interface: 1,\n"
112 " switch: 1,\n"
113 "};");
Daniel Jasper09840ef2015-11-20 15:58:50 +0000114 verifyFormat("var struct = 2;");
115 verifyFormat("var union = 2;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000116}
117
Daniel Jasper0dd52912014-05-19 07:37:07 +0000118TEST_F(FormatTestJS, ES6DestructuringAssignment) {
119 verifyFormat("var [a, b, c] = [1, 2, 3];");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000120 verifyFormat("let [a, b, c] = [1, 2, 3];");
Daniel Jasper60948b12015-03-15 13:55:54 +0000121 verifyFormat("var {a, b} = {a: 1, b: 2};");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000122 verifyFormat("let {a, b} = {a: 1, b: 2};");
Daniel Jasper0dd52912014-05-19 07:37:07 +0000123}
124
Daniel Jasper17062ff2014-06-10 14:44:02 +0000125TEST_F(FormatTestJS, ContainerLiterals) {
Manuel Klimek79e06082015-05-21 12:23:34 +0000126 verifyFormat("var x = {y: function(a) { return a; }};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000127 verifyFormat("return {\n"
128 " link: function() {\n"
129 " f(); //\n"
130 " }\n"
131 "};");
132 verifyFormat("return {\n"
133 " a: a,\n"
134 " link: function() {\n"
135 " f(); //\n"
136 " }\n"
137 "};");
138 verifyFormat("return {\n"
139 " a: a,\n"
Daniel Jasper90ebc982014-09-05 09:27:38 +0000140 " link: function() {\n"
141 " f(); //\n"
142 " },\n"
143 " link: function() {\n"
144 " f(); //\n"
145 " }\n"
Daniel Jasper17062ff2014-06-10 14:44:02 +0000146 "};");
Daniel Jasper94e11d02014-09-04 14:58:30 +0000147 verifyFormat("var stuff = {\n"
148 " // comment for update\n"
149 " update: false,\n"
150 " // comment for modules\n"
151 " modules: false,\n"
152 " // comment for tasks\n"
153 " tasks: false\n"
154 "};");
Daniel Jasper97bfb7b2014-09-05 08:29:31 +0000155 verifyFormat("return {\n"
156 " 'finish':\n"
157 " //\n"
158 " a\n"
159 "};");
Daniel Jasper40874322014-11-27 15:24:48 +0000160 verifyFormat("var obj = {\n"
161 " fooooooooo: function(x) {\n"
162 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
163 " }\n"
164 "};");
Daniel Jasper60948b12015-03-15 13:55:54 +0000165 // Simple object literal, as opposed to enum style below.
166 verifyFormat("var obj = {a: 123};");
167 // Enum style top level assignment.
168 verifyFormat("X = {\n a: 123\n};");
169 verifyFormat("X.Y = {\n a: 123\n};");
Daniel Jasper11ca2632015-06-10 09:21:09 +0000170 // But only on the top level, otherwise its a plain object literal assignment.
171 verifyFormat("function x() {\n"
172 " y = {z: 1};\n"
173 "}");
Daniel Jasper60948b12015-03-15 13:55:54 +0000174 verifyFormat("x = foo && {a: 123};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000175
176 // Arrow functions in object literals.
177 verifyFormat("var x = {y: (a) => { return a; }};");
178 verifyFormat("var x = {y: (a) => a};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000179
180 // Computed keys.
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000181 verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000182 verifyFormat("var x = {\n"
183 " [a]: 1,\n"
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000184 " b: 2,\n"
185 " [c]: 3,\n"
Daniel Jasper8c42d442015-05-29 06:19:49 +0000186 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000187}
188
Daniel Jasperf46dec82015-03-31 14:34:15 +0000189TEST_F(FormatTestJS, MethodsInObjectLiterals) {
190 verifyFormat("var o = {\n"
191 " value: 'test',\n"
192 " get value() { // getter\n"
193 " return this.value;\n"
194 " }\n"
195 "};");
196 verifyFormat("var o = {\n"
197 " value: 'test',\n"
198 " set value(val) { // setter\n"
199 " this.value = val;\n"
200 " }\n"
201 "};");
202 verifyFormat("var o = {\n"
203 " value: 'test',\n"
204 " someMethod(val) { // method\n"
205 " doSomething(this.value + val);\n"
206 " }\n"
207 "};");
Daniel Jasper739ec532015-04-04 07:56:55 +0000208 verifyFormat("var o = {\n"
209 " someMethod(val) { // method\n"
210 " doSomething(this.value + val);\n"
211 " },\n"
212 " someOtherMethod(val) { // method\n"
213 " doSomething(this.value + val);\n"
214 " }\n"
215 "};");
Daniel Jasperf46dec82015-03-31 14:34:15 +0000216}
217
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000218TEST_F(FormatTestJS, SpacesInContainerLiterals) {
219 verifyFormat("var arr = [1, 2, 3];");
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000220 verifyFormat("f({a: 1, b: 2, c: 3});");
Nico Weber514ecc82014-02-02 20:50:45 +0000221
Daniel Jasper2a958322014-05-21 13:26:58 +0000222 verifyFormat("var object_literal_with_long_name = {\n"
223 " a: 'aaaaaaaaaaaaaaaaaa',\n"
224 " b: 'bbbbbbbbbbbbbbbbbb'\n"
225 "};");
226
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000227 verifyFormat("f({a: 1, b: 2, c: 3});",
Nico Weber514ecc82014-02-02 20:50:45 +0000228 getChromiumStyle(FormatStyle::LK_JavaScript));
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000229 verifyFormat("f({'a': [{}]});");
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000230}
231
Daniel Jasper86fee2f2014-01-31 12:49:42 +0000232TEST_F(FormatTestJS, SingleQuoteStrings) {
233 verifyFormat("this.function('', true);");
234}
235
Daniel Jasper4a39c842014-05-06 13:54:10 +0000236TEST_F(FormatTestJS, GoogScopes) {
237 verifyFormat("goog.scope(function() {\n"
238 "var x = a.b;\n"
239 "var y = c.d;\n"
240 "}); // goog.scope");
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000241 verifyFormat("goog.scope(function() {\n"
242 "// test\n"
243 "var x = 0;\n"
244 "// test\n"
245 "});");
Daniel Jasper4a39c842014-05-06 13:54:10 +0000246}
247
Daniel Jasper616de8642014-11-23 16:46:28 +0000248TEST_F(FormatTestJS, GoogModules) {
249 verifyFormat("goog.module('this.is.really.absurdly.long');",
250 getGoogleJSStyleWithColumns(40));
251 verifyFormat("goog.require('this.is.really.absurdly.long');",
252 getGoogleJSStyleWithColumns(40));
253 verifyFormat("goog.provide('this.is.really.absurdly.long');",
254 getGoogleJSStyleWithColumns(40));
255 verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
256 getGoogleJSStyleWithColumns(40));
Daniel Jasperb488a742015-10-29 19:05:20 +0000257 verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
258 getGoogleJSStyleWithColumns(40));
Daniel Jasper53c38f42014-11-27 14:46:03 +0000259
260 // These should be wrapped normally.
261 verifyFormat(
262 "var MyLongClassName =\n"
263 " goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
Daniel Jasper616de8642014-11-23 16:46:28 +0000264}
265
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000266TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
267 verifyFormat("function outer1(a, b) {\n"
268 " function inner1(a, b) { return a; }\n"
269 " inner1(a, b);\n"
270 "}\n"
271 "function outer2(a, b) {\n"
272 " function inner2(a, b) { return a; }\n"
273 " inner2(a, b);\n"
274 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000275 verifyFormat("function f() {}");
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000276}
277
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000278TEST_F(FormatTestJS, ArrayLiterals) {
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000279 verifyFormat("var aaaaa: List<SomeThing> =\n"
280 " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000281 verifyFormat("return [\n"
282 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
283 " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
284 " ccccccccccccccccccccccccccc\n"
285 "];");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000286 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper5ce80de2015-06-02 13:56:43 +0000287 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
288 " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
289 " ccccccccccccccccccccccccccc\n"
290 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000291 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper40432ce2015-06-02 15:04:29 +0000292 " [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
Daniel Jasper199d0c92015-06-02 15:14:21 +0000293 "]);",
294 getGoogleJSStyleWithColumns(51));
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000295 verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
Daniel Jasper4284e362015-06-02 14:20:08 +0000296 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
297 " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
298 " ccccccccccccccccccccccccccc\n"
299 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000300 verifyFormat("var someVariable = SomeFunction(\n"
301 " aaaa,\n"
302 " [\n"
303 " aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
304 " bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
305 " ccccccccccccccccccccccccccc\n"
306 " ],\n"
307 " aaaa);");
Daniel Jasper1feab0f2015-06-02 15:31:37 +0000308
309 verifyFormat("someFunction([], {a: a});");
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000310}
311
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000312TEST_F(FormatTestJS, FunctionLiterals) {
Daniel Jasper3f69ba12014-09-05 08:42:27 +0000313 verifyFormat("doFoo(function() {});");
Daniel Jasper79dffb42014-05-07 09:48:30 +0000314 verifyFormat("doFoo(function() { return 1; });");
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000315 verifyFormat("var func = function() {\n"
316 " return 1;\n"
317 "};");
Daniel Jaspered3f3952015-06-18 12:32:59 +0000318 verifyFormat("var func = //\n"
319 " function() {\n"
320 " return 1;\n"
321 "};");
Daniel Jasperc03e16a2014-05-08 09:25:39 +0000322 verifyFormat("return {\n"
323 " body: {\n"
324 " setAttribute: function(key, val) { this[key] = val; },\n"
325 " getAttribute: function(key) { return this[key]; },\n"
326 " style: {direction: ''}\n"
327 " }\n"
328 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000329 verifyFormat("abc = xyz ? function() {\n"
330 " return 1;\n"
331 "} : function() {\n"
332 " return -1;\n"
333 "};");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000334
335 verifyFormat("var closure = goog.bind(\n"
336 " function() { // comment\n"
337 " foo();\n"
338 " bar();\n"
339 " },\n"
340 " this, arg1IsReallyLongAndNeeedsLineBreaks,\n"
341 " arg3IsReallyLongAndNeeedsLineBreaks);");
342 verifyFormat("var closure = goog.bind(function() { // comment\n"
343 " foo();\n"
344 " bar();\n"
345 "}, this);");
Daniel Jasper58cb2ed2014-06-06 13:49:04 +0000346 verifyFormat("return {\n"
347 " a: 'E',\n"
348 " b: function() {\n"
349 " return function() {\n"
350 " f(); //\n"
351 " };\n"
352 " }\n"
353 "};");
Daniel Jasper41368e92014-11-27 15:37:42 +0000354 verifyFormat("{\n"
355 " var someVariable = function(x) {\n"
356 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
357 " };\n"
358 "}");
Daniel Jasper7325aee2015-05-08 08:38:52 +0000359 verifyFormat("someLooooooooongFunction(\n"
360 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
361 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
362 " function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
363 " // code\n"
364 " });");
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000365
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000366 verifyFormat("f({a: function() { return 1; }});",
367 getGoogleJSStyleWithColumns(33));
368 verifyFormat("f({\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000369 " a: function() { return 1; }\n"
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000370 "});",
371 getGoogleJSStyleWithColumns(32));
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000372
373 verifyFormat("return {\n"
374 " a: function SomeFunction() {\n"
375 " // ...\n"
376 " return 1;\n"
377 " }\n"
378 "};");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000379 verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
380 " .then(goog.bind(function(aaaaaaaaaaa) {\n"
381 " someFunction();\n"
382 " someFunction();\n"
383 " }, this), aaaaaaaaaaaaaaaaa);");
384
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000385 verifyFormat("someFunction(goog.bind(function() {\n"
386 " doSomething();\n"
387 " doSomething();\n"
388 "}, this), goog.bind(function() {\n"
389 " doSomething();\n"
390 " doSomething();\n"
391 "}, this));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000392
393 // FIXME: This is bad, we should be wrapping before "function() {".
394 verifyFormat("someFunction(function() {\n"
395 " doSomething(); // break\n"
396 "})\n"
397 " .doSomethingElse(\n"
398 " // break\n"
399 " );");
Daniel Jasper79dffb42014-05-07 09:48:30 +0000400}
401
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000402TEST_F(FormatTestJS, InliningFunctionLiterals) {
403 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
404 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
405 verifyFormat("var func = function() {\n"
406 " return 1;\n"
407 "};",
408 Style);
409 verifyFormat("var func = doSomething(function() { return 1; });", Style);
410 verifyFormat("var outer = function() {\n"
411 " var inner = function() { return 1; }\n"
412 "};",
413 Style);
414 verifyFormat("function outer1(a, b) {\n"
415 " function inner1(a, b) { return a; }\n"
416 "}",
417 Style);
418
419 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
420 verifyFormat("var func = function() { return 1; };", Style);
421 verifyFormat("var func = doSomething(function() { return 1; });", Style);
422 verifyFormat(
423 "var outer = function() { var inner = function() { return 1; } };",
424 Style);
425 verifyFormat("function outer1(a, b) {\n"
426 " function inner1(a, b) { return a; }\n"
427 "}",
428 Style);
429
430 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
431 verifyFormat("var func = function() {\n"
432 " return 1;\n"
433 "};",
434 Style);
435 verifyFormat("var func = doSomething(function() {\n"
436 " return 1;\n"
437 "});",
438 Style);
439 verifyFormat("var outer = function() {\n"
440 " var inner = function() {\n"
441 " return 1;\n"
442 " }\n"
443 "};",
444 Style);
445 verifyFormat("function outer1(a, b) {\n"
446 " function inner1(a, b) {\n"
447 " return a;\n"
448 " }\n"
449 "}",
450 Style);
451}
452
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000453TEST_F(FormatTestJS, MultipleFunctionLiterals) {
454 verifyFormat("promise.then(\n"
455 " function success() {\n"
456 " doFoo();\n"
457 " doBar();\n"
458 " },\n"
459 " function error() {\n"
460 " doFoo();\n"
461 " doBaz();\n"
462 " },\n"
463 " []);\n");
464 verifyFormat("promise.then(\n"
465 " function success() {\n"
466 " doFoo();\n"
467 " doBar();\n"
468 " },\n"
469 " [],\n"
470 " function error() {\n"
471 " doFoo();\n"
472 " doBaz();\n"
473 " });\n");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000474 verifyFormat("promise.then(\n"
475 " [],\n"
476 " function success() {\n"
477 " doFoo();\n"
478 " doBar();\n"
479 " },\n"
480 " function error() {\n"
481 " doFoo();\n"
482 " doBaz();\n"
483 " });\n");
Daniel Jasper1779d432014-09-29 07:54:54 +0000484
485 verifyFormat("getSomeLongPromise()\n"
486 " .then(function(value) { body(); })\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000487 " .thenCatch(function(error) {\n"
488 " body();\n"
489 " body();\n"
490 " });");
Daniel Jasper1779d432014-09-29 07:54:54 +0000491 verifyFormat("getSomeLongPromise()\n"
492 " .then(function(value) {\n"
493 " body();\n"
494 " body();\n"
495 " })\n"
496 " .thenCatch(function(error) {\n"
497 " body();\n"
498 " body();\n"
499 " });");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000500
Daniel Jasperacf67e32015-04-07 08:20:35 +0000501 verifyFormat("getSomeLongPromise()\n"
502 " .then(function(value) { body(); })\n"
503 " .thenCatch(function(error) { body(); });");
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000504}
505
Manuel Klimek79e06082015-05-21 12:23:34 +0000506TEST_F(FormatTestJS, ArrowFunctions) {
507 verifyFormat("var x = (a) => {\n"
508 " return a;\n"
509 "};");
510 verifyFormat("var x = (a) => {\n"
511 " function y() { return 42; }\n"
512 " return a;\n"
513 "};");
514 verifyFormat("var x = (a: type): {some: type} => {\n"
515 " return a;\n"
516 "};");
517 verifyFormat("var x = (a) => a;");
Daniel Jaspere497bed2015-06-02 22:06:07 +0000518 verifyFormat("return () => [];");
Daniel Jasper3c306e82015-06-03 17:08:40 +0000519 verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
520 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
521 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
522 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
Daniel Jasper3b0f3042015-06-05 08:25:37 +0000523 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper3c306e82015-06-03 17:08:40 +0000524 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000525 verifyFormat("var a = a.aaaaaaa(\n"
526 " (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
527 " aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
528 verifyFormat("var a = a.aaaaaaa(\n"
529 " (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
530 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
531 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000532
533 // FIXME: This is bad, we should be wrapping before "() => {".
534 verifyFormat("someFunction(() => {\n"
535 " doSomething(); // break\n"
536 "})\n"
537 " .doSomethingElse(\n"
538 " // break\n"
539 " );");
Manuel Klimek79e06082015-05-21 12:23:34 +0000540}
541
Daniel Jasper166c19b2014-05-06 14:12:21 +0000542TEST_F(FormatTestJS, ReturnStatements) {
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000543 verifyFormat("function() {\n"
544 " return [hello, world];\n"
545 "}");
Daniel Jasper166c19b2014-05-06 14:12:21 +0000546}
547
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000548TEST_F(FormatTestJS, AutomaticSemicolonInsertion) {
549 // The following statements must not wrap, as otherwise the program meaning
550 // would change due to automatic semicolon insertion.
551 // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
552 verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
553 verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
554 verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
555 verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
556 verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
557 verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
558}
559
Manuel Klimek79e06082015-05-21 12:23:34 +0000560TEST_F(FormatTestJS, ClosureStyleCasts) {
Daniel Jasper484033b2014-05-06 14:41:29 +0000561 verifyFormat("var x = /** @type {foo} */ (bar);");
562}
563
Daniel Jasper04a71a42014-05-08 11:58:24 +0000564TEST_F(FormatTestJS, TryCatch) {
565 verifyFormat("try {\n"
566 " f();\n"
567 "} catch (e) {\n"
568 " g();\n"
569 "} finally {\n"
570 " h();\n"
571 "}");
Daniel Jasper8f2e94c2014-09-04 15:03:34 +0000572
573 // But, of course, "catch" is a perfectly fine function name in JavaScript.
574 verifyFormat("someObject.catch();");
Daniel Jasper79121232014-11-27 14:55:17 +0000575 verifyFormat("someObject.new();");
576 verifyFormat("someObject.delete();");
Daniel Jasper04a71a42014-05-08 11:58:24 +0000577}
578
Daniel Jasper49802ef2014-05-22 09:10:04 +0000579TEST_F(FormatTestJS, StringLiteralConcatenation) {
580 verifyFormat("var literal = 'hello ' +\n"
581 " 'world';");
582}
583
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000584TEST_F(FormatTestJS, RegexLiteralClassification) {
585 // Regex literals.
586 verifyFormat("var regex = /abc/;");
587 verifyFormat("f(/abc/);");
588 verifyFormat("f(abc, /abc/);");
589 verifyFormat("some_map[/abc/];");
590 verifyFormat("var x = a ? /abc/ : /abc/;");
591 verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
592 verifyFormat("var x = !/abc/.test(y);");
593 verifyFormat("var x = a && /abc/.test(y);");
594 verifyFormat("var x = a || /abc/.test(y);");
595 verifyFormat("var x = a + /abc/.search(y);");
Daniel Jasperc553ae12015-07-02 13:20:45 +0000596 verifyFormat("/abc/.search(y);");
Daniel Jasperf7405c12014-05-08 07:45:18 +0000597 verifyFormat("var regexs = {/abc/, /abc/};");
598 verifyFormat("return /abc/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000599
600 // Not regex literals.
601 verifyFormat("var a = a / 2 + b / 3;");
Daniel Jasper265309e2015-10-18 07:02:28 +0000602 verifyFormat("var a = a++ / 2;");
603 // Prefix unary can operate on regex literals, not that it makes sense.
604 verifyFormat("var a = ++/a/;");
605
606 // This is a known issue, regular expressions are incorrectly detected if
607 // directly following a closing parenthesis.
608 verifyFormat("if (foo) / bar /.exec(baz);");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000609}
610
611TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
Daniel Jasper69694b02015-05-08 07:55:13 +0000612 verifyFormat("var regex = /=/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000613 verifyFormat("var regex = /a*/;");
614 verifyFormat("var regex = /a+/;");
615 verifyFormat("var regex = /a?/;");
616 verifyFormat("var regex = /.a./;");
617 verifyFormat("var regex = /a\\*/;");
618 verifyFormat("var regex = /^a$/;");
619 verifyFormat("var regex = /\\/a/;");
620 verifyFormat("var regex = /(?:x)/;");
621 verifyFormat("var regex = /x(?=y)/;");
622 verifyFormat("var regex = /x(?!y)/;");
623 verifyFormat("var regex = /x|y/;");
624 verifyFormat("var regex = /a{2}/;");
625 verifyFormat("var regex = /a{1,3}/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000626
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000627 verifyFormat("var regex = /[abc]/;");
628 verifyFormat("var regex = /[^abc]/;");
629 verifyFormat("var regex = /[\\b]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000630 verifyFormat("var regex = /[/]/;");
631 verifyFormat("var regex = /[\\/]/;");
632 verifyFormat("var regex = /\\[/;");
633 verifyFormat("var regex = /\\\\[/]/;");
Daniel Jasper265309e2015-10-18 07:02:28 +0000634 verifyFormat("var regex = /}[\"]/;");
635 verifyFormat("var regex = /}[/\"]/;");
636 verifyFormat("var regex = /}[\"/]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000637
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000638 verifyFormat("var regex = /\\b/;");
639 verifyFormat("var regex = /\\B/;");
640 verifyFormat("var regex = /\\d/;");
641 verifyFormat("var regex = /\\D/;");
642 verifyFormat("var regex = /\\f/;");
643 verifyFormat("var regex = /\\n/;");
644 verifyFormat("var regex = /\\r/;");
645 verifyFormat("var regex = /\\s/;");
646 verifyFormat("var regex = /\\S/;");
647 verifyFormat("var regex = /\\t/;");
648 verifyFormat("var regex = /\\v/;");
649 verifyFormat("var regex = /\\w/;");
650 verifyFormat("var regex = /\\W/;");
651 verifyFormat("var regex = /a(a)\\1/;");
652 verifyFormat("var regex = /\\0/;");
Daniel Jasperfb4333b2014-05-12 11:29:50 +0000653 verifyFormat("var regex = /\\\\/g;");
654 verifyFormat("var regex = /\\a\\\\/g;");
655 verifyFormat("var regex = /\a\\//g;");
Daniel Jasper23376252014-09-09 14:37:39 +0000656 verifyFormat("var regex = /a\\//;\n"
657 "var x = 0;");
Daniel Jasper6b8d26c2015-06-24 16:01:02 +0000658 EXPECT_EQ("var regex = /'/g;", format("var regex = /'/g ;"));
659 EXPECT_EQ("var regex = /'/g; //'", format("var regex = /'/g ; //'"));
Daniel Jasper49a9a282014-10-29 16:51:38 +0000660 EXPECT_EQ("var regex = /\\/*/;\n"
661 "var x = 0;",
662 format("var regex = /\\/*/;\n"
663 "var x=0;"));
Daniel Jasper55c384e2015-07-02 14:01:34 +0000664 EXPECT_EQ("var x = /a\\//;", format("var x = /a\\// \n;"));
Daniel Jasper6b8d26c2015-06-24 16:01:02 +0000665 verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
666 verifyFormat("var regex =\n"
667 " /\"/;",
668 getGoogleJSStyleWithColumns(15));
Daniel Jasperf7372152015-07-02 14:14:04 +0000669 verifyFormat("var regex = //\n"
670 " /a/;");
Daniel Jasperf1446202015-07-02 15:00:44 +0000671 verifyFormat("var regexs = [\n"
672 " /d/, //\n"
673 " /aa/, //\n"
674 "];");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000675}
676
677TEST_F(FormatTestJS, RegexLiteralModifiers) {
678 verifyFormat("var regex = /abc/g;");
679 verifyFormat("var regex = /abc/i;");
680 verifyFormat("var regex = /abc/m;");
681 verifyFormat("var regex = /abc/y;");
682}
683
684TEST_F(FormatTestJS, RegexLiteralLength) {
685 verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
686 getGoogleJSStyleWithColumns(60));
687 verifyFormat("var regex =\n"
688 " /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
689 getGoogleJSStyleWithColumns(60));
Daniel Jasper0580ff02014-12-17 09:11:08 +0000690 verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
691 getGoogleJSStyleWithColumns(50));
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000692}
693
694TEST_F(FormatTestJS, RegexLiteralExamples) {
695 verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
696}
697
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000698TEST_F(FormatTestJS, TypeAnnotations) {
699 verifyFormat("var x: string;");
700 verifyFormat("function x(): string {\n return 'x';\n}");
Manuel Klimek79e06082015-05-21 12:23:34 +0000701 verifyFormat("function x(): {x: string} {\n return {x: 'x'};\n}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000702 verifyFormat("function x(y: string): string {\n return 'x';\n}");
703 verifyFormat("for (var y: string in x) {\n x();\n}");
704 verifyFormat("((a: string, b: number): string => a + b);");
705 verifyFormat("var x: (y: number) => string;");
706 verifyFormat("var x: P<string, (a: number) => string>;");
Manuel Klimek79e06082015-05-21 12:23:34 +0000707 verifyFormat("var x = {y: function(): z { return 1; }};");
708 verifyFormat("var x = {y: function(): {a: number} { return 1; }};");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000709}
710
Daniel Jasper83709082015-02-18 17:14:05 +0000711TEST_F(FormatTestJS, ClassDeclarations) {
712 verifyFormat("class C {\n x: string = 12;\n}");
713 verifyFormat("class C {\n x(): string => 12;\n}");
714 verifyFormat("class C {\n ['x' + 2]: string = 12;\n}");
715 verifyFormat("class C {\n private x: string = 12;\n}");
716 verifyFormat("class C {\n private static x: string = 12;\n}");
717 verifyFormat("class C {\n static x(): string { return 'asd'; }\n}");
718 verifyFormat("class C extends P implements I {}");
Daniel Jasper6a5d38d2015-04-13 14:56:54 +0000719 verifyFormat("class C extends p.P implements i.I {}");
Daniel Jasperb9a52812015-07-10 13:39:26 +0000720 verifyFormat("class Test {\n"
721 " aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
722 " aaaaaaaaaaaaaaaaaaaaaa {}\n"
723 "}");
Daniel Jasper81dbb562015-06-03 08:43:18 +0000724
725 // ':' is not a type declaration here.
726 verifyFormat("class X {\n"
727 " subs = {\n"
728 " 'b': {\n"
729 " 'c': 1,\n"
730 " },\n"
731 " };\n"
732 "}");
Daniel Jasper83709082015-02-18 17:14:05 +0000733}
734
Daniel Jasper29647492015-05-05 08:12:50 +0000735TEST_F(FormatTestJS, InterfaceDeclarations) {
736 verifyFormat("interface I {\n"
737 " x: string;\n"
Daniel Jasper259188b2015-06-12 04:56:34 +0000738 "}\n"
739 "var y;");
Daniel Jasper5c235c02015-07-06 14:26:04 +0000740 // Ensure that state is reset after parsing the interface.
741 verifyFormat("interface a {}\n"
742 "export function b() {}\n"
743 "var x;");
Daniel Jasper29647492015-05-05 08:12:50 +0000744}
745
Daniel Jasper90cf3802015-06-17 09:44:02 +0000746TEST_F(FormatTestJS, EnumDeclarations) {
747 verifyFormat("enum Foo {\n"
Daniel Jasper9f4ec152015-06-17 09:44:07 +0000748 " A = 1,\n"
749 " B\n"
750 "}");
751 verifyFormat("export /* somecomment*/ enum Foo {\n"
752 " A = 1,\n"
753 " B\n"
754 "}");
755 verifyFormat("enum Foo {\n"
Daniel Jasper90cf3802015-06-17 09:44:02 +0000756 " A = 1, // comment\n"
757 " B\n"
758 "}\n"
759 "var x = 1;");
760}
761
Daniel Jasper3c42dba2015-02-18 17:17:15 +0000762TEST_F(FormatTestJS, MetadataAnnotations) {
763 verifyFormat("@A\nclass C {\n}");
764 verifyFormat("@A({arg: 'value'})\nclass C {\n}");
765 verifyFormat("@A\n@B\nclass C {\n}");
766 verifyFormat("class C {\n @A x: string;\n}");
767 verifyFormat("class C {\n"
768 " @A\n"
769 " private x(): string {\n"
770 " return 'y';\n"
771 " }\n"
772 "}");
Daniel Jasper6fa9ec72015-02-19 16:03:16 +0000773 verifyFormat("class X {}\n"
774 "class Y {}");
Daniel Jasper3c42dba2015-02-18 17:17:15 +0000775}
776
Daniel Jasper354aa512015-02-19 16:07:32 +0000777TEST_F(FormatTestJS, Modules) {
778 verifyFormat("import SomeThing from 'some/module.js';");
779 verifyFormat("import {X, Y} from 'some/module.js';");
780 verifyFormat("import {\n"
781 " VeryLongImportsAreAnnoying,\n"
782 " VeryLongImportsAreAnnoying,\n"
783 " VeryLongImportsAreAnnoying,\n"
784 " VeryLongImportsAreAnnoying\n"
785 "} from 'some/module.js';");
786 verifyFormat("import {\n"
787 " X,\n"
788 " Y,\n"
789 "} from 'some/module.js';");
790 verifyFormat("import {\n"
791 " X,\n"
792 " Y,\n"
793 "} from 'some/long/module.js';",
794 getGoogleJSStyleWithColumns(20));
795 verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
796 verifyFormat("import * as lib from 'some/module.js';");
Daniel Jasper60948b12015-03-15 13:55:54 +0000797 verifyFormat("var x = {import: 1};\nx.import = 2;");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000798
799 verifyFormat("export function fn() {\n"
800 " return 'fn';\n"
801 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000802 verifyFormat("export function A() {}\n"
803 "export default function B() {}\n"
804 "export function C() {}");
Daniel Jasper354aa512015-02-19 16:07:32 +0000805 verifyFormat("export const x = 12;");
806 verifyFormat("export default class X {}");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000807 verifyFormat("export {X, Y} from 'some/module.js';");
808 verifyFormat("export {\n"
809 " X,\n"
810 " Y,\n"
811 "} from 'some/module.js';");
812 verifyFormat("export class C {\n"
813 " x: number;\n"
814 " y: string;\n"
815 "}");
816 verifyFormat("export class X { y: number; }");
817 verifyFormat("export default class X { y: number }");
818 verifyFormat("export default function() {\n return 1;\n}");
819 verifyFormat("export var x = 12;");
Daniel Jasper910807d2015-06-12 04:52:02 +0000820 verifyFormat("class C {}\n"
821 "export function f() {}\n"
822 "var v;");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000823 verifyFormat("export var x: number = 12;");
824 verifyFormat("export const y = {\n"
825 " a: 1,\n"
826 " b: 2\n"
827 "};");
Daniel Jasper216c9cd2015-06-12 05:08:18 +0000828 verifyFormat("export enum Foo {\n"
829 " BAR,\n"
830 " // adsdasd\n"
831 " BAZ\n"
832 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +0000833}
834
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000835TEST_F(FormatTestJS, TemplateStrings) {
836 // Keeps any whitespace/indentation within the template string.
837 EXPECT_EQ("var x = `hello\n"
838 " ${ name }\n"
839 " !`;",
840 format("var x = `hello\n"
841 " ${ name }\n"
842 " !`;"));
843
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000844 verifyFormat("var x =\n"
845 " `hello ${world}` >= some();",
846 getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
847 verifyFormat("var x = `hello ${world}` >= some();",
Daniel Jasper553a5b02015-07-02 13:08:28 +0000848 getGoogleJSStyleWithColumns(35)); // Barely fits.
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000849 EXPECT_EQ("var x = `hello\n"
850 " ${world}` >=\n"
851 " some();",
852 format("var x =\n"
853 " `hello\n"
854 " ${world}` >= some();",
855 getGoogleJSStyleWithColumns(21))); // Barely doesn't fit.
856 EXPECT_EQ("var x = `hello\n"
857 " ${world}` >= some();",
858 format("var x =\n"
859 " `hello\n"
860 " ${world}` >= some();",
861 getGoogleJSStyleWithColumns(22))); // Barely fits.
862
Daniel Jasper553a5b02015-07-02 13:08:28 +0000863 verifyFormat("var x =\n"
864 " `h`;",
865 getGoogleJSStyleWithColumns(11));
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000866 EXPECT_EQ(
867 "var x =\n `multi\n line`;",
Daniel Jasper553a5b02015-07-02 13:08:28 +0000868 format("var x = `multi\n line`;", getGoogleJSStyleWithColumns(13)));
869 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
870 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000871
Daniel Jasperf69b9222015-05-02 08:05:38 +0000872 // Make sure template strings get a proper ColumnWidth assigned, even if they
873 // are first token in line.
874 verifyFormat(
875 "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
876 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
877
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000878 // Two template strings.
879 verifyFormat("var x = `hello` == `hello`;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +0000880
881 // Comments in template strings.
882 EXPECT_EQ("var x = `//a`;\n"
883 "var y;",
884 format("var x =\n `//a`;\n"
885 "var y ;"));
886 EXPECT_EQ("var x = `/*a`;\n"
887 "var y;",
888 format("var x =\n `/*a`;\n"
889 "var y;"));
Daniel Jasper2ebb0c52015-06-14 07:16:57 +0000890 // Unterminated string literals in a template string.
891 verifyFormat("var x = `'`; // comment with matching quote '\n"
892 "var y;");
893 verifyFormat("var x = `\"`; // comment with matching quote \"\n"
894 "var y;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +0000895 // Backticks in a comment - not a template string.
896 EXPECT_EQ("var x = 1 // `/*a`;\n"
897 " ;",
898 format("var x =\n 1 // `/*a`;\n"
899 " ;"));
900 EXPECT_EQ("/* ` */ var x = 1; /* ` */",
901 format("/* ` */ var x\n= 1; /* ` */"));
902 // Comment spans multiple template strings.
903 EXPECT_EQ("var x = `/*a`;\n"
904 "var y = ` */ `;",
905 format("var x =\n `/*a`;\n"
906 "var y =\n ` */ `;"));
907 // Escaped backtick.
908 EXPECT_EQ("var x = ` \\` a`;\n"
909 "var y;",
910 format("var x = ` \\` a`;\n"
911 "var y;"));
Daniel Jaspera0ef4f32015-02-20 13:47:38 +0000912}
913
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000914TEST_F(FormatTestJS, CastSyntax) { verifyFormat("var x = <type>foo;"); }
Daniel Jasperbc46b932015-03-15 13:59:51 +0000915
916TEST_F(FormatTestJS, TypeArguments) {
917 verifyFormat("class X<Y> {}");
918 verifyFormat("new X<Y>();");
919 verifyFormat("foo<Y>(a);");
920 verifyFormat("var x: X<Y>[];");
921 verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000922 verifyFormat("function f(a: List<any> = null) {}");
923 verifyFormat("function f(): List<any> {}");
Daniel Jasper5a3de1d2015-07-03 10:37:23 +0000924 verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
925 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000926 verifyFormat("function aaaaaaaaaa(\n"
927 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
928 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
Daniel Jasperb2328b12015-07-06 14:07:51 +0000929 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
Daniel Jasperbc46b932015-03-15 13:59:51 +0000930}
931
Daniel Jaspera74f5072015-04-13 15:01:40 +0000932TEST_F(FormatTestJS, OptionalTypes) {
Daniel Jasper20580fd2015-06-11 13:31:45 +0000933 verifyFormat("function x(a?: b, c?, d?) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +0000934 verifyFormat("class X {\n"
935 " y?: z;\n"
936 " z?;\n"
937 "}");
Daniel Jasper9326f912015-05-05 08:40:32 +0000938 verifyFormat("interface X {\n"
939 " y?(): z;\n"
940 "}");
941 verifyFormat("x ? 1 : 2;");
Daniel Jasper3e0dcc22015-05-27 05:37:40 +0000942 verifyFormat("constructor({aa}: {\n"
943 " aa?: string,\n"
944 " aaaaaaaa?: string,\n"
945 " aaaaaaaaaaaaaaa?: boolean,\n"
946 " aaaaaa?: List<string>\n"
Daniel Jasper20580fd2015-06-11 13:31:45 +0000947 "}) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +0000948}
949
Daniel Jasperd9309772015-04-13 15:03:30 +0000950TEST_F(FormatTestJS, IndexSignature) {
951 verifyFormat("var x: {[k: string]: v};");
952}
953
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000954TEST_F(FormatTestJS, WrapAfterParen) {
955 verifyFormat("xxxxxxxxxxx(\n"
956 " aaa, aaa);",
957 getGoogleJSStyleWithColumns(20));
958 verifyFormat("xxxxxxxxxxx(\n"
959 " aaa, aaa, aaa,\n"
960 " aaa, aaa, aaa);",
961 getGoogleJSStyleWithColumns(20));
962 verifyFormat("xxxxxxxxxxx(\n"
963 " aaaaaaaaaaaaaaaaaaaaaaaa,\n"
964 " function(x) {\n"
965 " y(); //\n"
966 " });",
967 getGoogleJSStyleWithColumns(40));
968 verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
969 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
970}
971
Alexander Kornienkoab9db512015-06-22 23:07:51 +0000972} // end namespace tooling
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000973} // end namespace clang