blob: 912682449e39f0c9cf1730b9e93e6738d355d185 [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 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
65TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
66 verifyFormat("a == = b;");
67 verifyFormat("a != = b;");
68
69 verifyFormat("a === b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000070 verifyFormat("aaaaaaa ===\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000071 verifyFormat("a !== b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000072 verifyFormat("aaaaaaa !==\n b;", getGoogleJSStyleWithColumns(10));
73 verifyFormat("if (a + b + c +\n"
74 " d !==\n"
75 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000076 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000077 getGoogleJSStyleWithColumns(20));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000078
79 verifyFormat("a >> >= b;");
80
81 verifyFormat("a >>> b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000082 verifyFormat("aaaaaaa >>>\n b;", getGoogleJSStyleWithColumns(10));
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000083 verifyFormat("a >>>= b;");
Daniel Jaspere551bb72014-11-05 17:22:31 +000084 verifyFormat("aaaaaaa >>>=\n b;", getGoogleJSStyleWithColumns(10));
85 verifyFormat("if (a + b + c +\n"
86 " d >>>\n"
87 " e + f + g)\n"
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +000088 " q();",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000089 getGoogleJSStyleWithColumns(20));
Daniel Jaspere551bb72014-11-05 17:22:31 +000090 verifyFormat("var x = aaaaaaaaaa ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +000091 " bbbbbb :\n"
92 " ccc;",
Alexander Kornienkoc1637f12013-12-10 11:28:13 +000093 getGoogleJSStyleWithColumns(20));
Daniel Jasper78214392014-05-19 07:27:02 +000094
95 verifyFormat("var b = a.map((x) => x + 1);");
Daniel Jasper3549ea12014-09-19 10:48:15 +000096 verifyFormat("return ('aaa') in bbbb;");
Daniel Jasper1ce41112016-02-01 11:20:47 +000097 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
98 " aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
99 FormatStyle Style = getGoogleJSStyleWithColumns(80);
100 Style.AlignOperands = true;
101 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
102 " aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
103 Style);
104 Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
105 verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa()\n"
106 " in aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
107 Style);
Daniel Jasper08051992015-05-26 07:18:56 +0000108
109 // ES6 spread operator.
110 verifyFormat("someFunction(...a);");
111 verifyFormat("var x = [1, ...a, 2];");
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +0000112}
113
Daniel Jasper3a038de2014-09-05 08:53:45 +0000114TEST_F(FormatTestJS, UnderstandsAmpAmp) {
115 verifyFormat("e && e.SomeFunction();");
116}
117
Daniel Jasper4db69bd2014-09-04 18:23:42 +0000118TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
119 verifyFormat("not.and.or.not_eq = 1;");
120}
121
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000122TEST_F(FormatTestJS, ReservedWords) {
123 // JavaScript reserved words (aka keywords) are only illegal when used as
124 // Identifiers, but are legal as IdentifierNames.
125 verifyFormat("x.class.struct = 1;");
126 verifyFormat("x.case = 1;");
127 verifyFormat("x.interface = 1;");
Daniel Jaspera4607e12016-03-17 12:17:59 +0000128 verifyFormat("x.of() = 1;");
129 verifyFormat("x.in() = 1;");
130 verifyFormat("x.let() = 1;");
131 verifyFormat("x.var() = 1;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000132 verifyFormat("x = {\n"
133 " a: 12,\n"
134 " interface: 1,\n"
135 " switch: 1,\n"
136 "};");
Daniel Jasper09840ef2015-11-20 15:58:50 +0000137 verifyFormat("var struct = 2;");
138 verifyFormat("var union = 2;");
Daniel Jasperba52fcb2015-09-28 14:29:45 +0000139}
140
Daniel Jasper72a1b6a2015-12-22 15:47:56 +0000141TEST_F(FormatTestJS, CppKeywords) {
142 // Make sure we don't mess stuff up because of C++ keywords.
143 verifyFormat("return operator && (aa);");
144}
145
Daniel Jasper0dd52912014-05-19 07:37:07 +0000146TEST_F(FormatTestJS, ES6DestructuringAssignment) {
147 verifyFormat("var [a, b, c] = [1, 2, 3];");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000148 verifyFormat("let [a, b, c] = [1, 2, 3];");
Daniel Jasper60948b12015-03-15 13:55:54 +0000149 verifyFormat("var {a, b} = {a: 1, b: 2};");
Daniel Jasper9f642f72015-09-28 14:28:08 +0000150 verifyFormat("let {a, b} = {a: 1, b: 2};");
Daniel Jasper0dd52912014-05-19 07:37:07 +0000151}
152
Daniel Jasper17062ff2014-06-10 14:44:02 +0000153TEST_F(FormatTestJS, ContainerLiterals) {
Manuel Klimek79e06082015-05-21 12:23:34 +0000154 verifyFormat("var x = {y: function(a) { return a; }};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000155 verifyFormat("return {\n"
156 " link: function() {\n"
157 " f(); //\n"
158 " }\n"
159 "};");
160 verifyFormat("return {\n"
161 " a: a,\n"
162 " link: function() {\n"
163 " f(); //\n"
164 " }\n"
165 "};");
166 verifyFormat("return {\n"
167 " a: a,\n"
Daniel Jasper90ebc982014-09-05 09:27:38 +0000168 " link: function() {\n"
169 " f(); //\n"
170 " },\n"
171 " link: function() {\n"
172 " f(); //\n"
173 " }\n"
Daniel Jasper17062ff2014-06-10 14:44:02 +0000174 "};");
Daniel Jasper94e11d02014-09-04 14:58:30 +0000175 verifyFormat("var stuff = {\n"
176 " // comment for update\n"
177 " update: false,\n"
178 " // comment for modules\n"
179 " modules: false,\n"
180 " // comment for tasks\n"
181 " tasks: false\n"
182 "};");
Daniel Jasper97bfb7b2014-09-05 08:29:31 +0000183 verifyFormat("return {\n"
184 " 'finish':\n"
185 " //\n"
186 " a\n"
187 "};");
Daniel Jasper40874322014-11-27 15:24:48 +0000188 verifyFormat("var obj = {\n"
189 " fooooooooo: function(x) {\n"
190 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
191 " }\n"
192 "};");
Daniel Jasper60948b12015-03-15 13:55:54 +0000193 // Simple object literal, as opposed to enum style below.
194 verifyFormat("var obj = {a: 123};");
195 // Enum style top level assignment.
196 verifyFormat("X = {\n a: 123\n};");
197 verifyFormat("X.Y = {\n a: 123\n};");
Daniel Jasper11ca2632015-06-10 09:21:09 +0000198 // But only on the top level, otherwise its a plain object literal assignment.
199 verifyFormat("function x() {\n"
200 " y = {z: 1};\n"
201 "}");
Daniel Jasper60948b12015-03-15 13:55:54 +0000202 verifyFormat("x = foo && {a: 123};");
Manuel Klimek79e06082015-05-21 12:23:34 +0000203
204 // Arrow functions in object literals.
205 verifyFormat("var x = {y: (a) => { return a; }};");
206 verifyFormat("var x = {y: (a) => a};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000207
208 // Computed keys.
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000209 verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
Daniel Jasper8c42d442015-05-29 06:19:49 +0000210 verifyFormat("var x = {\n"
211 " [a]: 1,\n"
Daniel Jaspercd8d4ff2015-05-31 08:40:37 +0000212 " b: 2,\n"
213 " [c]: 3,\n"
Daniel Jasper8c42d442015-05-29 06:19:49 +0000214 "};");
Daniel Jasper9f4c9d42016-02-07 22:17:13 +0000215
216 // Object literals can leave out labels.
217 verifyFormat("f({a}, () => {\n"
218 " g(); //\n"
219 "});");
Daniel Jasperb18425b2016-03-01 04:19:47 +0000220
221 // Keys can be quoted.
222 verifyFormat("var x = {\n"
223 " a: a,\n"
224 " b: b,\n"
225 " 'c': c,\n"
226 "};");
Daniel Jasper17062ff2014-06-10 14:44:02 +0000227}
228
Daniel Jasperf46dec82015-03-31 14:34:15 +0000229TEST_F(FormatTestJS, MethodsInObjectLiterals) {
230 verifyFormat("var o = {\n"
231 " value: 'test',\n"
232 " get value() { // getter\n"
233 " return this.value;\n"
234 " }\n"
235 "};");
236 verifyFormat("var o = {\n"
237 " value: 'test',\n"
238 " set value(val) { // setter\n"
239 " this.value = val;\n"
240 " }\n"
241 "};");
242 verifyFormat("var o = {\n"
243 " value: 'test',\n"
244 " someMethod(val) { // method\n"
245 " doSomething(this.value + val);\n"
246 " }\n"
247 "};");
Daniel Jasper739ec532015-04-04 07:56:55 +0000248 verifyFormat("var o = {\n"
249 " someMethod(val) { // method\n"
250 " doSomething(this.value + val);\n"
251 " },\n"
252 " someOtherMethod(val) { // method\n"
253 " doSomething(this.value + val);\n"
254 " }\n"
255 "};");
Daniel Jasperf46dec82015-03-31 14:34:15 +0000256}
257
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000258TEST_F(FormatTestJS, SpacesInContainerLiterals) {
259 verifyFormat("var arr = [1, 2, 3];");
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000260 verifyFormat("f({a: 1, b: 2, c: 3});");
Nico Weber514ecc82014-02-02 20:50:45 +0000261
Daniel Jasper2a958322014-05-21 13:26:58 +0000262 verifyFormat("var object_literal_with_long_name = {\n"
263 " a: 'aaaaaaaaaaaaaaaaaa',\n"
264 " b: 'bbbbbbbbbbbbbbbbbb'\n"
265 "};");
266
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000267 verifyFormat("f({a: 1, b: 2, c: 3});",
Nico Weber514ecc82014-02-02 20:50:45 +0000268 getChromiumStyle(FormatStyle::LK_JavaScript));
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000269 verifyFormat("f({'a': [{}]});");
Daniel Jasperb2e10a52014-01-15 15:09:08 +0000270}
271
Daniel Jasperabd1f572016-03-02 22:44:03 +0000272TEST_F(FormatTestJS, SingleQuotedStrings) {
Daniel Jasper86fee2f2014-01-31 12:49:42 +0000273 verifyFormat("this.function('', true);");
274}
275
Daniel Jasper4a39c842014-05-06 13:54:10 +0000276TEST_F(FormatTestJS, GoogScopes) {
277 verifyFormat("goog.scope(function() {\n"
278 "var x = a.b;\n"
279 "var y = c.d;\n"
280 "}); // goog.scope");
Daniel Jasper02c7bca2015-03-30 09:56:50 +0000281 verifyFormat("goog.scope(function() {\n"
282 "// test\n"
283 "var x = 0;\n"
284 "// test\n"
285 "});");
Daniel Jasper4a39c842014-05-06 13:54:10 +0000286}
287
Daniel Jasper616de8642014-11-23 16:46:28 +0000288TEST_F(FormatTestJS, GoogModules) {
289 verifyFormat("goog.module('this.is.really.absurdly.long');",
290 getGoogleJSStyleWithColumns(40));
291 verifyFormat("goog.require('this.is.really.absurdly.long');",
292 getGoogleJSStyleWithColumns(40));
293 verifyFormat("goog.provide('this.is.really.absurdly.long');",
294 getGoogleJSStyleWithColumns(40));
295 verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
296 getGoogleJSStyleWithColumns(40));
Daniel Jasperb488a742015-10-29 19:05:20 +0000297 verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
298 getGoogleJSStyleWithColumns(40));
Daniel Jasper02cbeb22016-02-22 15:06:53 +0000299 verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
300 getGoogleJSStyleWithColumns(40));
Daniel Jasper53c38f42014-11-27 14:46:03 +0000301
302 // These should be wrapped normally.
303 verifyFormat(
304 "var MyLongClassName =\n"
305 " goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
Daniel Jasper616de8642014-11-23 16:46:28 +0000306}
307
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000308TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
309 verifyFormat("function outer1(a, b) {\n"
310 " function inner1(a, b) { return a; }\n"
311 " inner1(a, b);\n"
312 "}\n"
313 "function outer2(a, b) {\n"
314 " function inner2(a, b) { return a; }\n"
315 " inner2(a, b);\n"
316 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000317 verifyFormat("function f() {}");
Daniel Jasperad9eb0d2014-06-30 13:24:54 +0000318}
319
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000320TEST_F(FormatTestJS, ArrayLiterals) {
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +0000321 verifyFormat("var aaaaa: List<SomeThing> =\n"
322 " [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000323 verifyFormat("return [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000324 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasperd492b5e2015-06-02 21:57:51 +0000325 " ccccccccccccccccccccccccccc\n"
326 "];");
Daniel Jasper7bec87c2016-01-07 18:11:54 +0000327 verifyFormat("return [\n"
328 " aaaa().bbbbbbbb('A'),\n"
329 " aaaa().bbbbbbbb('B'),\n"
330 " aaaa().bbbbbbbb('C'),\n"
331 "];");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000332 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000333 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper5ce80de2015-06-02 13:56:43 +0000334 " ccccccccccccccccccccccccccc\n"
335 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000336 verifyFormat("var someVariable = SomeFunction([\n"
Daniel Jasper40432ce2015-06-02 15:04:29 +0000337 " [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
Daniel Jasper199d0c92015-06-02 15:14:21 +0000338 "]);",
339 getGoogleJSStyleWithColumns(51));
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000340 verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000341 " aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
Daniel Jasper4284e362015-06-02 14:20:08 +0000342 " ccccccccccccccccccccccccccc\n"
343 "]);");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000344 verifyFormat("var someVariable = SomeFunction(\n"
345 " aaaa,\n"
346 " [\n"
Daniel Jasper50780ce2016-01-13 16:41:34 +0000347 " aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
348 " cccccccccccccccccccccccccc\n"
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000349 " ],\n"
350 " aaaa);");
Daniel Jasperebcb71f2016-01-04 13:11:41 +0000351 verifyFormat("var aaaa = aaaaa || // wrap\n"
352 " [];");
Daniel Jasper1feab0f2015-06-02 15:31:37 +0000353
354 verifyFormat("someFunction([], {a: a});");
Daniel Jasperf841d3a2015-05-28 07:21:50 +0000355}
356
Daniel Jaspere2deb592015-12-22 15:48:15 +0000357TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
358 verifyFormat("var array = [\n"
359 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
360 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
361 "];");
362 verifyFormat("var array = someFunction([\n"
363 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
364 " a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
365 "]);");
366}
367
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000368TEST_F(FormatTestJS, FunctionLiterals) {
Daniel Jasper3f69ba12014-09-05 08:42:27 +0000369 verifyFormat("doFoo(function() {});");
Daniel Jasper79dffb42014-05-07 09:48:30 +0000370 verifyFormat("doFoo(function() { return 1; });");
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000371 verifyFormat("var func = function() {\n"
372 " return 1;\n"
373 "};");
Daniel Jaspered3f3952015-06-18 12:32:59 +0000374 verifyFormat("var func = //\n"
375 " function() {\n"
376 " return 1;\n"
377 "};");
Daniel Jasperc03e16a2014-05-08 09:25:39 +0000378 verifyFormat("return {\n"
379 " body: {\n"
380 " setAttribute: function(key, val) { this[key] = val; },\n"
381 " getAttribute: function(key) { return this[key]; },\n"
382 " style: {direction: ''}\n"
383 " }\n"
384 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000385 verifyFormat("abc = xyz ? function() {\n"
386 " return 1;\n"
387 "} : function() {\n"
388 " return -1;\n"
389 "};");
Daniel Jasperb16b9692014-05-21 12:51:23 +0000390
391 verifyFormat("var closure = goog.bind(\n"
392 " function() { // comment\n"
393 " foo();\n"
394 " bar();\n"
395 " },\n"
396 " this, arg1IsReallyLongAndNeeedsLineBreaks,\n"
397 " arg3IsReallyLongAndNeeedsLineBreaks);");
398 verifyFormat("var closure = goog.bind(function() { // comment\n"
399 " foo();\n"
400 " bar();\n"
401 "}, this);");
Daniel Jasper58cb2ed2014-06-06 13:49:04 +0000402 verifyFormat("return {\n"
403 " a: 'E',\n"
404 " b: function() {\n"
405 " return function() {\n"
406 " f(); //\n"
407 " };\n"
408 " }\n"
409 "};");
Daniel Jasper41368e92014-11-27 15:37:42 +0000410 verifyFormat("{\n"
411 " var someVariable = function(x) {\n"
412 " return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
413 " };\n"
414 "}");
Daniel Jasper7325aee2015-05-08 08:38:52 +0000415 verifyFormat("someLooooooooongFunction(\n"
416 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
417 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
418 " function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
419 " // code\n"
420 " });");
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000421
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000422 verifyFormat("f({a: function() { return 1; }});",
423 getGoogleJSStyleWithColumns(33));
424 verifyFormat("f({\n"
Daniel Jasper5f3ea472014-05-22 08:36:53 +0000425 " a: function() { return 1; }\n"
Daniel Jaspera4e55f42014-12-04 16:07:17 +0000426 "});",
427 getGoogleJSStyleWithColumns(32));
Daniel Jasper5217a8b2014-06-13 07:02:04 +0000428
429 verifyFormat("return {\n"
430 " a: function SomeFunction() {\n"
431 " // ...\n"
432 " return 1;\n"
433 " }\n"
434 "};");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000435 verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
436 " .then(goog.bind(function(aaaaaaaaaaa) {\n"
437 " someFunction();\n"
438 " someFunction();\n"
439 " }, this), aaaaaaaaaaaaaaaaa);");
440
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000441 verifyFormat("someFunction(goog.bind(function() {\n"
442 " doSomething();\n"
443 " doSomething();\n"
444 "}, this), goog.bind(function() {\n"
445 " doSomething();\n"
446 " doSomething();\n"
447 "}, this));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000448
449 // FIXME: This is bad, we should be wrapping before "function() {".
450 verifyFormat("someFunction(function() {\n"
451 " doSomething(); // break\n"
452 "})\n"
453 " .doSomethingElse(\n"
454 " // break\n"
455 " );");
Daniel Jasper79dffb42014-05-07 09:48:30 +0000456}
457
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000458TEST_F(FormatTestJS, InliningFunctionLiterals) {
459 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
460 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
461 verifyFormat("var func = function() {\n"
462 " return 1;\n"
463 "};",
464 Style);
465 verifyFormat("var func = doSomething(function() { return 1; });", Style);
466 verifyFormat("var outer = function() {\n"
467 " var inner = function() { return 1; }\n"
468 "};",
469 Style);
470 verifyFormat("function outer1(a, b) {\n"
471 " function inner1(a, b) { return a; }\n"
472 "}",
473 Style);
474
475 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
476 verifyFormat("var func = function() { return 1; };", Style);
477 verifyFormat("var func = doSomething(function() { return 1; });", Style);
478 verifyFormat(
479 "var outer = function() { var inner = function() { return 1; } };",
480 Style);
481 verifyFormat("function outer1(a, b) {\n"
482 " function inner1(a, b) { return a; }\n"
483 "}",
484 Style);
485
486 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
487 verifyFormat("var func = function() {\n"
488 " return 1;\n"
489 "};",
490 Style);
491 verifyFormat("var func = doSomething(function() {\n"
492 " return 1;\n"
493 "});",
494 Style);
495 verifyFormat("var outer = function() {\n"
496 " var inner = function() {\n"
497 " return 1;\n"
498 " }\n"
499 "};",
500 Style);
501 verifyFormat("function outer1(a, b) {\n"
502 " function inner1(a, b) {\n"
503 " return a;\n"
504 " }\n"
505 "}",
506 Style);
Daniel Jasper71e57452015-11-20 16:44:28 +0000507
508 Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
509 verifyFormat("var func = function() {\n"
510 " return 1;\n"
511 "};",
512 Style);
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000513}
514
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000515TEST_F(FormatTestJS, MultipleFunctionLiterals) {
516 verifyFormat("promise.then(\n"
517 " function success() {\n"
518 " doFoo();\n"
519 " doBar();\n"
520 " },\n"
521 " function error() {\n"
522 " doFoo();\n"
523 " doBaz();\n"
524 " },\n"
525 " []);\n");
526 verifyFormat("promise.then(\n"
527 " function success() {\n"
528 " doFoo();\n"
529 " doBar();\n"
530 " },\n"
531 " [],\n"
532 " function error() {\n"
533 " doFoo();\n"
534 " doBaz();\n"
535 " });\n");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000536 verifyFormat("promise.then(\n"
537 " [],\n"
538 " function success() {\n"
539 " doFoo();\n"
540 " doBar();\n"
541 " },\n"
542 " function error() {\n"
543 " doFoo();\n"
544 " doBaz();\n"
545 " });\n");
Daniel Jasper1779d432014-09-29 07:54:54 +0000546
547 verifyFormat("getSomeLongPromise()\n"
548 " .then(function(value) { body(); })\n"
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000549 " .thenCatch(function(error) {\n"
550 " body();\n"
551 " body();\n"
552 " });");
Daniel Jasper1779d432014-09-29 07:54:54 +0000553 verifyFormat("getSomeLongPromise()\n"
554 " .then(function(value) {\n"
555 " body();\n"
556 " body();\n"
557 " })\n"
558 " .thenCatch(function(error) {\n"
559 " body();\n"
560 " body();\n"
561 " });");
Daniel Jasper11a0ac62014-12-12 09:40:58 +0000562
Daniel Jasperacf67e32015-04-07 08:20:35 +0000563 verifyFormat("getSomeLongPromise()\n"
564 " .then(function(value) { body(); })\n"
565 " .thenCatch(function(error) { body(); });");
Daniel Jasper28024562016-01-11 11:00:58 +0000566
567 verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
568 " .aaaaaaa(function() {\n"
569 " //\n"
570 " })\n"
571 " .bbbbbb();");
Daniel Jasper114a2bc2014-06-03 12:02:45 +0000572}
573
Manuel Klimek79e06082015-05-21 12:23:34 +0000574TEST_F(FormatTestJS, ArrowFunctions) {
575 verifyFormat("var x = (a) => {\n"
576 " return a;\n"
577 "};");
578 verifyFormat("var x = (a) => {\n"
579 " function y() { return 42; }\n"
580 " return a;\n"
581 "};");
582 verifyFormat("var x = (a: type): {some: type} => {\n"
583 " return a;\n"
584 "};");
585 verifyFormat("var x = (a) => a;");
Daniel Jaspere497bed2015-06-02 22:06:07 +0000586 verifyFormat("return () => [];");
Daniel Jasper3c306e82015-06-03 17:08:40 +0000587 verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
588 " aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
589 " (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
590 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
Daniel Jasper3b0f3042015-06-05 08:25:37 +0000591 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
Daniel Jasper3c306e82015-06-03 17:08:40 +0000592 "};");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000593 verifyFormat("var a = a.aaaaaaa(\n"
594 " (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000595 " aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper6501f7e2015-10-27 12:38:37 +0000596 verifyFormat("var a = a.aaaaaaa(\n"
597 " (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000598 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
599 " aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
Daniel Jasper1699eca2015-06-01 09:56:32 +0000600
601 // FIXME: This is bad, we should be wrapping before "() => {".
602 verifyFormat("someFunction(() => {\n"
603 " doSomething(); // break\n"
604 "})\n"
605 " .doSomethingElse(\n"
606 " // break\n"
607 " );");
Manuel Klimek79e06082015-05-21 12:23:34 +0000608}
609
Daniel Jasper166c19b2014-05-06 14:12:21 +0000610TEST_F(FormatTestJS, ReturnStatements) {
Daniel Jasper67f8ad22014-09-30 17:57:06 +0000611 verifyFormat("function() {\n"
612 " return [hello, world];\n"
613 "}");
Daniel Jasper166c19b2014-05-06 14:12:21 +0000614}
615
Daniel Jasperf95b1f42015-11-20 16:18:42 +0000616TEST_F(FormatTestJS, ForLoops) {
617 verifyFormat("for (var i in [2, 3]) {\n"
618 "}");
Daniel Jasperb7fda112016-02-11 13:24:15 +0000619 verifyFormat("for (var i of [2, 3]) {\n"
620 "}");
Daniel Jasperacffeb82016-03-05 18:34:26 +0000621 verifyFormat("for (let {a, b} of x) {\n"
622 "}");
623 verifyFormat("for (let {a, b} in x) {\n"
624 "}");
Daniel Jasperf95b1f42015-11-20 16:18:42 +0000625}
626
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000627TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000628 // The following statements must not wrap, as otherwise the program meaning
629 // would change due to automatic semicolon insertion.
630 // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
631 verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
632 verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
633 verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
634 verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
635 verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
636 verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
Daniel Jasper11a87652016-01-14 05:37:52 +0000637 verifyFormat("return [\n"
638 " aaa\n"
639 "];",
640 getGoogleJSStyleWithColumns(12));
Daniel Jasper4c0bf702015-06-12 04:58:27 +0000641}
642
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000643TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
644 verifyFormat("a\n"
645 "b;",
646 " a \n"
647 " b ;");
648 verifyFormat("a()\n"
649 "b;",
650 " a ()\n"
651 " b ;");
652 verifyFormat("a[b]\n"
653 "c;",
654 "a [b]\n"
655 "c ;");
656 verifyFormat("1\n"
657 "a;",
658 "1 \n"
659 "a ;");
660 verifyFormat("a\n"
661 "1;",
662 "a \n"
663 "1 ;");
664 verifyFormat("a\n"
665 "'x';",
666 "a \n"
667 " 'x';");
668 verifyFormat("a++\n"
669 "b;",
670 "a ++\n"
671 "b ;");
672 verifyFormat("a\n"
673 "!b && c;",
674 "a \n"
675 " ! b && c;");
676 verifyFormat("a\n"
677 "if (1) f();",
678 " a\n"
679 " if (1) f();");
680 verifyFormat("a\n"
681 "class X {}",
682 " a\n"
683 " class X {}");
684 verifyFormat("var a", "var\n"
685 "a");
686 verifyFormat("x instanceof String", "x\n"
687 "instanceof\n"
688 "String");
Martin Probstbbffeac2016-04-11 07:35:57 +0000689 verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
690 " bar) {}");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000691}
692
Manuel Klimek79e06082015-05-21 12:23:34 +0000693TEST_F(FormatTestJS, ClosureStyleCasts) {
Daniel Jasper484033b2014-05-06 14:41:29 +0000694 verifyFormat("var x = /** @type {foo} */ (bar);");
695}
696
Daniel Jasper04a71a42014-05-08 11:58:24 +0000697TEST_F(FormatTestJS, TryCatch) {
698 verifyFormat("try {\n"
699 " f();\n"
700 "} catch (e) {\n"
701 " g();\n"
702 "} finally {\n"
703 " h();\n"
704 "}");
Daniel Jasper8f2e94c2014-09-04 15:03:34 +0000705
706 // But, of course, "catch" is a perfectly fine function name in JavaScript.
707 verifyFormat("someObject.catch();");
Daniel Jasper79121232014-11-27 14:55:17 +0000708 verifyFormat("someObject.new();");
709 verifyFormat("someObject.delete();");
Daniel Jasper04a71a42014-05-08 11:58:24 +0000710}
711
Daniel Jasper49802ef2014-05-22 09:10:04 +0000712TEST_F(FormatTestJS, StringLiteralConcatenation) {
713 verifyFormat("var literal = 'hello ' +\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +0000714 " 'world';");
Daniel Jasper49802ef2014-05-22 09:10:04 +0000715}
716
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000717TEST_F(FormatTestJS, RegexLiteralClassification) {
718 // Regex literals.
719 verifyFormat("var regex = /abc/;");
720 verifyFormat("f(/abc/);");
721 verifyFormat("f(abc, /abc/);");
722 verifyFormat("some_map[/abc/];");
723 verifyFormat("var x = a ? /abc/ : /abc/;");
724 verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
725 verifyFormat("var x = !/abc/.test(y);");
726 verifyFormat("var x = a && /abc/.test(y);");
727 verifyFormat("var x = a || /abc/.test(y);");
728 verifyFormat("var x = a + /abc/.search(y);");
Daniel Jasperc553ae12015-07-02 13:20:45 +0000729 verifyFormat("/abc/.search(y);");
Daniel Jasperf7405c12014-05-08 07:45:18 +0000730 verifyFormat("var regexs = {/abc/, /abc/};");
731 verifyFormat("return /abc/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000732
733 // Not regex literals.
734 verifyFormat("var a = a / 2 + b / 3;");
Daniel Jasper265309e2015-10-18 07:02:28 +0000735 verifyFormat("var a = a++ / 2;");
736 // Prefix unary can operate on regex literals, not that it makes sense.
737 verifyFormat("var a = ++/a/;");
738
739 // This is a known issue, regular expressions are incorrectly detected if
740 // directly following a closing parenthesis.
741 verifyFormat("if (foo) / bar /.exec(baz);");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000742}
743
744TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
Daniel Jasper69694b02015-05-08 07:55:13 +0000745 verifyFormat("var regex = /=/;");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000746 verifyFormat("var regex = /a*/;");
747 verifyFormat("var regex = /a+/;");
748 verifyFormat("var regex = /a?/;");
749 verifyFormat("var regex = /.a./;");
750 verifyFormat("var regex = /a\\*/;");
751 verifyFormat("var regex = /^a$/;");
752 verifyFormat("var regex = /\\/a/;");
753 verifyFormat("var regex = /(?:x)/;");
754 verifyFormat("var regex = /x(?=y)/;");
755 verifyFormat("var regex = /x(?!y)/;");
756 verifyFormat("var regex = /x|y/;");
757 verifyFormat("var regex = /a{2}/;");
758 verifyFormat("var regex = /a{1,3}/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000759
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000760 verifyFormat("var regex = /[abc]/;");
761 verifyFormat("var regex = /[^abc]/;");
762 verifyFormat("var regex = /[\\b]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000763 verifyFormat("var regex = /[/]/;");
764 verifyFormat("var regex = /[\\/]/;");
765 verifyFormat("var regex = /\\[/;");
766 verifyFormat("var regex = /\\\\[/]/;");
Daniel Jasper265309e2015-10-18 07:02:28 +0000767 verifyFormat("var regex = /}[\"]/;");
768 verifyFormat("var regex = /}[/\"]/;");
769 verifyFormat("var regex = /}[\"/]/;");
Daniel Jasper8d0e2232015-10-12 03:13:48 +0000770
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000771 verifyFormat("var regex = /\\b/;");
772 verifyFormat("var regex = /\\B/;");
773 verifyFormat("var regex = /\\d/;");
774 verifyFormat("var regex = /\\D/;");
775 verifyFormat("var regex = /\\f/;");
776 verifyFormat("var regex = /\\n/;");
777 verifyFormat("var regex = /\\r/;");
778 verifyFormat("var regex = /\\s/;");
779 verifyFormat("var regex = /\\S/;");
780 verifyFormat("var regex = /\\t/;");
781 verifyFormat("var regex = /\\v/;");
782 verifyFormat("var regex = /\\w/;");
783 verifyFormat("var regex = /\\W/;");
784 verifyFormat("var regex = /a(a)\\1/;");
785 verifyFormat("var regex = /\\0/;");
Daniel Jasperfb4333b2014-05-12 11:29:50 +0000786 verifyFormat("var regex = /\\\\/g;");
787 verifyFormat("var regex = /\\a\\\\/g;");
788 verifyFormat("var regex = /\a\\//g;");
Daniel Jasper23376252014-09-09 14:37:39 +0000789 verifyFormat("var regex = /a\\//;\n"
790 "var x = 0;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +0000791 verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
792 verifyFormat("var regex = /'/g; //'", "var regex = /'/g ; //'");
793 verifyFormat("var regex = /\\/*/;\n"
794 "var x = 0;",
795 "var regex = /\\/*/;\n"
796 "var x=0;");
797 verifyFormat("var x = /a\\//;", "var x = /a\\// \n;");
Daniel Jasper6b8d26c2015-06-24 16:01:02 +0000798 verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
799 verifyFormat("var regex =\n"
800 " /\"/;",
801 getGoogleJSStyleWithColumns(15));
Daniel Jasperf7372152015-07-02 14:14:04 +0000802 verifyFormat("var regex = //\n"
803 " /a/;");
Daniel Jasperf1446202015-07-02 15:00:44 +0000804 verifyFormat("var regexs = [\n"
805 " /d/, //\n"
806 " /aa/, //\n"
807 "];");
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000808}
809
810TEST_F(FormatTestJS, RegexLiteralModifiers) {
811 verifyFormat("var regex = /abc/g;");
812 verifyFormat("var regex = /abc/i;");
813 verifyFormat("var regex = /abc/m;");
814 verifyFormat("var regex = /abc/y;");
815}
816
817TEST_F(FormatTestJS, RegexLiteralLength) {
818 verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
819 getGoogleJSStyleWithColumns(60));
820 verifyFormat("var regex =\n"
821 " /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
822 getGoogleJSStyleWithColumns(60));
Daniel Jasper0580ff02014-12-17 09:11:08 +0000823 verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
824 getGoogleJSStyleWithColumns(50));
Daniel Jasperf9ae3122014-05-08 07:01:45 +0000825}
826
827TEST_F(FormatTestJS, RegexLiteralExamples) {
828 verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
829}
830
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000831TEST_F(FormatTestJS, TypeAnnotations) {
832 verifyFormat("var x: string;");
Daniel Jasperb9a49902016-01-09 15:56:28 +0000833 verifyFormat("var x: {a: string; b: number;} = {};");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000834 verifyFormat("function x(): string {\n return 'x';\n}");
Manuel Klimek79e06082015-05-21 12:23:34 +0000835 verifyFormat("function x(): {x: string} {\n return {x: 'x'};\n}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000836 verifyFormat("function x(y: string): string {\n return 'x';\n}");
837 verifyFormat("for (var y: string in x) {\n x();\n}");
Daniel Jasperb7fda112016-02-11 13:24:15 +0000838 verifyFormat("for (var y: string of x) {\n x();\n}");
Daniel Jasperb9a49902016-01-09 15:56:28 +0000839 verifyFormat("function x(y: {a?: number;} = {}): number {\n"
840 " return 12;\n"
841 "}");
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000842 verifyFormat("((a: string, b: number): string => a + b);");
843 verifyFormat("var x: (y: number) => string;");
844 verifyFormat("var x: P<string, (a: number) => string>;");
Manuel Klimek79e06082015-05-21 12:23:34 +0000845 verifyFormat("var x = {y: function(): z { return 1; }};");
846 verifyFormat("var x = {y: function(): {a: number} { return 1; }};");
Daniel Jasperf412e262016-01-08 10:51:24 +0000847 verifyFormat("function someFunc(args: string[]):\n"
848 " {longReturnValue: string[]} {}",
849 getGoogleJSStyleWithColumns(60));
Daniel Jasperb10bdff2015-02-18 17:09:53 +0000850}
851
Daniel Jasper91b1d1a2016-03-21 17:57:31 +0000852TEST_F(FormatTestJS, UnionIntersectionTypes) {
853 verifyFormat("let x: A|B = A | B;");
854 verifyFormat("let x: A&B|C = A & B;");
855 verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
856 verifyFormat("function(x: A|B): C&D {}");
857 verifyFormat("function(x: A|B = A | B): C&D {}");
858}
859
Daniel Jasper83709082015-02-18 17:14:05 +0000860TEST_F(FormatTestJS, ClassDeclarations) {
861 verifyFormat("class C {\n x: string = 12;\n}");
862 verifyFormat("class C {\n x(): string => 12;\n}");
863 verifyFormat("class C {\n ['x' + 2]: string = 12;\n}");
864 verifyFormat("class C {\n private x: string = 12;\n}");
865 verifyFormat("class C {\n private static x: string = 12;\n}");
866 verifyFormat("class C {\n static x(): string { return 'asd'; }\n}");
867 verifyFormat("class C extends P implements I {}");
Daniel Jasper6a5d38d2015-04-13 14:56:54 +0000868 verifyFormat("class C extends p.P implements i.I {}");
Daniel Jasperb9a52812015-07-10 13:39:26 +0000869 verifyFormat("class Test {\n"
870 " aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
871 " aaaaaaaaaaaaaaaaaaaaaa {}\n"
872 "}");
Daniel Jasperd5ec65b2016-01-08 07:06:07 +0000873 verifyFormat("foo = class Name {\n"
874 " constructor() {}\n"
875 "};");
876 verifyFormat("foo = class {\n"
877 " constructor() {}\n"
878 "};");
Daniel Jasperb9a49902016-01-09 15:56:28 +0000879 verifyFormat("class C {\n"
880 " x: {y: Z;} = {};\n"
881 " private y: {y: Z;} = {};\n"
882 "}");
Daniel Jasper81dbb562015-06-03 08:43:18 +0000883
884 // ':' is not a type declaration here.
885 verifyFormat("class X {\n"
886 " subs = {\n"
887 " 'b': {\n"
888 " 'c': 1,\n"
889 " },\n"
890 " };\n"
891 "}");
Daniel Jasper83709082015-02-18 17:14:05 +0000892}
893
Daniel Jasper29647492015-05-05 08:12:50 +0000894TEST_F(FormatTestJS, InterfaceDeclarations) {
895 verifyFormat("interface I {\n"
896 " x: string;\n"
Daniel Jasper6f5a1932015-12-29 08:54:23 +0000897 " enum: string[];\n"
Daniel Jasper87379302016-02-03 05:33:44 +0000898 " enum?: string[];\n"
Daniel Jasper259188b2015-06-12 04:56:34 +0000899 "}\n"
900 "var y;");
Daniel Jasper5c235c02015-07-06 14:26:04 +0000901 // Ensure that state is reset after parsing the interface.
902 verifyFormat("interface a {}\n"
903 "export function b() {}\n"
904 "var x;");
Daniel Jasperb542f9f2015-12-22 15:48:35 +0000905
906 // Arrays of object type literals.
907 verifyFormat("interface I {\n"
908 " o: {}[];\n"
909 "}");
Daniel Jasper29647492015-05-05 08:12:50 +0000910}
911
Daniel Jasper90cf3802015-06-17 09:44:02 +0000912TEST_F(FormatTestJS, EnumDeclarations) {
913 verifyFormat("enum Foo {\n"
Daniel Jasper9f4ec152015-06-17 09:44:07 +0000914 " A = 1,\n"
915 " B\n"
916 "}");
917 verifyFormat("export /* somecomment*/ enum Foo {\n"
918 " A = 1,\n"
919 " B\n"
920 "}");
921 verifyFormat("enum Foo {\n"
Daniel Jasper90cf3802015-06-17 09:44:02 +0000922 " A = 1, // comment\n"
923 " B\n"
924 "}\n"
925 "var x = 1;");
926}
927
Daniel Jasper3c42dba2015-02-18 17:17:15 +0000928TEST_F(FormatTestJS, MetadataAnnotations) {
929 verifyFormat("@A\nclass C {\n}");
930 verifyFormat("@A({arg: 'value'})\nclass C {\n}");
931 verifyFormat("@A\n@B\nclass C {\n}");
932 verifyFormat("class C {\n @A x: string;\n}");
933 verifyFormat("class C {\n"
934 " @A\n"
935 " private x(): string {\n"
936 " return 'y';\n"
937 " }\n"
938 "}");
Daniel Jasper6fa9ec72015-02-19 16:03:16 +0000939 verifyFormat("class X {}\n"
940 "class Y {}");
Daniel Jasper3c42dba2015-02-18 17:17:15 +0000941}
942
Daniel Jasper354aa512015-02-19 16:07:32 +0000943TEST_F(FormatTestJS, Modules) {
944 verifyFormat("import SomeThing from 'some/module.js';");
945 verifyFormat("import {X, Y} from 'some/module.js';");
Daniel Jasperefc1a832016-01-07 08:53:35 +0000946 verifyFormat("import a, {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +0000947 verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
948 " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
Daniel Jasper354aa512015-02-19 16:07:32 +0000949 "} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +0000950 verifyFormat("import {X, Y,} from 'some/module.js';");
Daniel Jasper354aa512015-02-19 16:07:32 +0000951 verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
952 verifyFormat("import * as lib from 'some/module.js';");
Daniel Jasper60948b12015-03-15 13:55:54 +0000953 verifyFormat("var x = {import: 1};\nx.import = 2;");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000954
955 verifyFormat("export function fn() {\n"
956 " return 'fn';\n"
957 "}");
Daniel Jasper20580fd2015-06-11 13:31:45 +0000958 verifyFormat("export function A() {}\n"
959 "export default function B() {}\n"
960 "export function C() {}");
Daniel Jasper354aa512015-02-19 16:07:32 +0000961 verifyFormat("export const x = 12;");
962 verifyFormat("export default class X {}");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000963 verifyFormat("export {X, Y} from 'some/module.js';");
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +0000964 verifyFormat("export {X, Y,} from 'some/module.js';");
965 verifyFormat("export {SomeVeryLongExport as X, "
966 "SomeOtherVeryLongExport as Y} from 'some/module.js';");
967 // export without 'from' is wrapped.
968 verifyFormat("export let someRatherLongVariableName =\n"
969 " someSurprisinglyLongVariable + someOtherRatherLongVar;");
970 // ... but not if from is just an identifier.
Daniel Jasperfca735c2015-02-19 16:14:18 +0000971 verifyFormat("export {\n"
Daniel Jasper8fc7a1e2016-03-22 14:32:20 +0000972 " from as from,\n"
973 " someSurprisinglyLongVariable\n"
974 " as from\n"
975 "};",
976 getGoogleJSStyleWithColumns(20));
Daniel Jasperfca735c2015-02-19 16:14:18 +0000977 verifyFormat("export class C {\n"
978 " x: number;\n"
979 " y: string;\n"
980 "}");
981 verifyFormat("export class X { y: number; }");
Daniel Jasper8620d4c2016-01-12 06:24:38 +0000982 verifyFormat("export abstract class X { y: number; }");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000983 verifyFormat("export default class X { y: number }");
984 verifyFormat("export default function() {\n return 1;\n}");
985 verifyFormat("export var x = 12;");
Daniel Jasper910807d2015-06-12 04:52:02 +0000986 verifyFormat("class C {}\n"
987 "export function f() {}\n"
988 "var v;");
Daniel Jasperfca735c2015-02-19 16:14:18 +0000989 verifyFormat("export var x: number = 12;");
990 verifyFormat("export const y = {\n"
991 " a: 1,\n"
992 " b: 2\n"
993 "};");
Daniel Jasper216c9cd2015-06-12 05:08:18 +0000994 verifyFormat("export enum Foo {\n"
995 " BAR,\n"
996 " // adsdasd\n"
997 " BAZ\n"
998 "}");
Daniel Jasperb14f6672016-01-04 15:51:56 +0000999 verifyFormat("export default [\n"
1000 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1001 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
1002 "];");
1003 verifyFormat("export default [];");
Daniel Jasper5e271462016-01-04 16:10:36 +00001004 verifyFormat("export default () => {};");
Daniel Jasperf55e4182016-01-11 22:57:40 +00001005 verifyFormat("export interface Foo { foo: number; }\n"
1006 "export class Bar {\n"
1007 " blah(): string { return this.blah; };\n"
1008 "}");
Daniel Jasper354aa512015-02-19 16:07:32 +00001009}
1010
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001011TEST_F(FormatTestJS, TemplateStrings) {
1012 // Keeps any whitespace/indentation within the template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001013 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001014 " ${ name }\n"
1015 " !`;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001016 "var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001017 " ${ name }\n"
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001018 " !`;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001019
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001020 verifyFormat("var x =\n"
1021 " `hello ${world}` >= some();",
1022 getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
1023 verifyFormat("var x = `hello ${world}` >= some();",
Daniel Jasper553a5b02015-07-02 13:08:28 +00001024 getGoogleJSStyleWithColumns(35)); // Barely fits.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001025 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001026 " ${world}` >=\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001027 " some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001028 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001029 " `hello\n"
1030 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001031 getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
1032 verifyFormat("var x = `hello\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001033 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001034 "var x =\n"
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001035 " `hello\n"
1036 " ${world}` >= some();",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001037 getGoogleJSStyleWithColumns(22)); // Barely fits.
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001038
Daniel Jasper553a5b02015-07-02 13:08:28 +00001039 verifyFormat("var x =\n"
1040 " `h`;",
1041 getGoogleJSStyleWithColumns(11));
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001042 verifyFormat("var x =\n `multi\n line`;", "var x = `multi\n line`;",
1043 getGoogleJSStyleWithColumns(13));
Daniel Jasper553a5b02015-07-02 13:08:28 +00001044 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1045 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001046
Daniel Jasperf69b9222015-05-02 08:05:38 +00001047 // Make sure template strings get a proper ColumnWidth assigned, even if they
1048 // are first token in line.
1049 verifyFormat(
1050 "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
Daniel Jasper41a2bf72015-12-21 13:52:19 +00001051 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
Daniel Jasperf69b9222015-05-02 08:05:38 +00001052
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001053 // Two template strings.
1054 verifyFormat("var x = `hello` == `hello`;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001055
1056 // Comments in template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001057 verifyFormat("var x = `//a`;\n"
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001058 "var y;",
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001059 "var x =\n `//a`;\n"
1060 "var y ;");
1061 verifyFormat("var x = `/*a`;\n"
1062 "var y;",
1063 "var x =\n `/*a`;\n"
1064 "var y;");
Daniel Jasper2ebb0c52015-06-14 07:16:57 +00001065 // Unterminated string literals in a template string.
1066 verifyFormat("var x = `'`; // comment with matching quote '\n"
1067 "var y;");
1068 verifyFormat("var x = `\"`; // comment with matching quote \"\n"
1069 "var y;");
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001070 verifyFormat("it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa);",
1071 "it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa) ;",
1072 getGoogleJSStyleWithColumns(40));
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001073 // Backticks in a comment - not a template string.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001074 verifyFormat("var x = 1 // `/*a`;\n"
1075 " ;",
1076 "var x =\n 1 // `/*a`;\n"
1077 " ;");
1078 verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001079 // Comment spans multiple template strings.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001080 verifyFormat("var x = `/*a`;\n"
1081 "var y = ` */ `;",
1082 "var x =\n `/*a`;\n"
1083 "var y =\n ` */ `;");
Daniel Jasper0d6ac272015-04-16 08:20:51 +00001084 // Escaped backtick.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001085 verifyFormat("var x = ` \\` a`;\n"
1086 "var y;",
1087 "var x = ` \\` a`;\n"
1088 "var y;");
Daniel Jaspera0ef4f32015-02-20 13:47:38 +00001089}
1090
Daniel Jaspere6fcf7d2015-06-17 13:08:06 +00001091TEST_F(FormatTestJS, CastSyntax) { verifyFormat("var x = <type>foo;"); }
Daniel Jasperbc46b932015-03-15 13:59:51 +00001092
1093TEST_F(FormatTestJS, TypeArguments) {
1094 verifyFormat("class X<Y> {}");
1095 verifyFormat("new X<Y>();");
1096 verifyFormat("foo<Y>(a);");
1097 verifyFormat("var x: X<Y>[];");
1098 verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
Daniel Jasper20580fd2015-06-11 13:31:45 +00001099 verifyFormat("function f(a: List<any> = null) {}");
1100 verifyFormat("function f(): List<any> {}");
Daniel Jasper5a3de1d2015-07-03 10:37:23 +00001101 verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1102 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001103 verifyFormat("function aaaaaaaaaa(\n"
1104 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1105 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
Daniel Jasperb2328b12015-07-06 14:07:51 +00001106 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
Daniel Jasperbc46b932015-03-15 13:59:51 +00001107}
1108
Daniel Jasper779c66f2015-12-30 08:00:58 +00001109TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1110 verifyFormat(
1111 "function foo(check: Object):\n"
1112 " check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1113 " return 'bar' in check;\n"
1114 "}\n");
1115}
1116
Daniel Jaspera74f5072015-04-13 15:01:40 +00001117TEST_F(FormatTestJS, OptionalTypes) {
Daniel Jasper20580fd2015-06-11 13:31:45 +00001118 verifyFormat("function x(a?: b, c?, d?) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001119 verifyFormat("class X {\n"
1120 " y?: z;\n"
1121 " z?;\n"
1122 "}");
Daniel Jasper9326f912015-05-05 08:40:32 +00001123 verifyFormat("interface X {\n"
1124 " y?(): z;\n"
1125 "}");
1126 verifyFormat("x ? 1 : 2;");
Daniel Jasper3e0dcc22015-05-27 05:37:40 +00001127 verifyFormat("constructor({aa}: {\n"
1128 " aa?: string,\n"
1129 " aaaaaaaa?: string,\n"
1130 " aaaaaaaaaaaaaaa?: boolean,\n"
1131 " aaaaaa?: List<string>\n"
Daniel Jasper20580fd2015-06-11 13:31:45 +00001132 "}) {}");
Daniel Jaspera74f5072015-04-13 15:01:40 +00001133}
1134
Daniel Jasperd9309772015-04-13 15:03:30 +00001135TEST_F(FormatTestJS, IndexSignature) {
1136 verifyFormat("var x: {[k: string]: v};");
1137}
1138
Daniel Jasper6501f7e2015-10-27 12:38:37 +00001139TEST_F(FormatTestJS, WrapAfterParen) {
1140 verifyFormat("xxxxxxxxxxx(\n"
1141 " aaa, aaa);",
1142 getGoogleJSStyleWithColumns(20));
1143 verifyFormat("xxxxxxxxxxx(\n"
1144 " aaa, aaa, aaa,\n"
1145 " aaa, aaa, aaa);",
1146 getGoogleJSStyleWithColumns(20));
1147 verifyFormat("xxxxxxxxxxx(\n"
1148 " aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1149 " function(x) {\n"
1150 " y(); //\n"
1151 " });",
1152 getGoogleJSStyleWithColumns(40));
1153 verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1154 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1155}
1156
Daniel Jasperd196abb2016-01-08 08:14:58 +00001157TEST_F(FormatTestJS, JSDocAnnotations) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001158 verifyFormat("/**\n"
1159 " * @export {this.is.a.long.path.to.a.Type}\n"
1160 " */",
1161 "/**\n"
1162 " * @export {this.is.a.long.path.to.a.Type}\n"
1163 " */",
1164 getGoogleJSStyleWithColumns(20));
Daniel Jasperd196abb2016-01-08 08:14:58 +00001165}
1166
Daniel Jasperabd1f572016-03-02 22:44:03 +00001167TEST_F(FormatTestJS, RequoteStringsSingle) {
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001168 verifyFormat("var x = 'foo';", "var x = \"foo\";");
1169 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
1170 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
1171 verifyFormat(
1172 "var x =\n"
1173 " 'foo\\'';",
1174 // Code below is 15 chars wide, doesn't fit into the line with the
1175 // \ escape added.
1176 "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
Daniel Jasperabd1f572016-03-02 22:44:03 +00001177 // Removes no-longer needed \ escape from ".
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001178 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
Daniel Jasperabd1f572016-03-02 22:44:03 +00001179 // Code below fits into 15 chars *after* removing the \ escape.
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001180 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
1181 getGoogleJSStyleWithColumns(15));
Daniel Jasperabd1f572016-03-02 22:44:03 +00001182}
1183
1184TEST_F(FormatTestJS, RequoteStringsDouble) {
1185 FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1186 DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
1187 verifyFormat("var x = \"foo\";", DoubleQuotes);
Daniel Jasper1dcbbcfc2016-03-14 19:21:36 +00001188 verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
1189 verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
Daniel Jasperabd1f572016-03-02 22:44:03 +00001190}
1191
1192TEST_F(FormatTestJS, RequoteStringsLeave) {
1193 FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
1194 LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
1195 verifyFormat("var x = \"foo\";", LeaveQuotes);
1196 verifyFormat("var x = 'foo';", LeaveQuotes);
1197}
1198
Alexander Kornienkoab9db512015-06-22 23:07:51 +00001199} // end namespace tooling
Alexander Kornienkoa48a12c2013-12-03 10:50:16 +00001200} // end namespace clang