xref: /llvm-project/clang/unittests/Format/FormatTestJS.cpp (revision f55e41824729fd4675aeff75de96ce6be3e5867a)
1 //===- 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 
10 #include "FormatTestUtils.h"
11 #include "clang/Format/Format.h"
12 #include "llvm/Support/Debug.h"
13 #include "gtest/gtest.h"
14 
15 #define DEBUG_TYPE "format-test"
16 
17 namespace clang {
18 namespace format {
19 
20 class FormatTestJS : public ::testing::Test {
21 protected:
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));
27     bool IncompleteFormat = false;
28     tooling::Replacements Replaces =
29         reformat(Style, Code, Ranges, "<stdin>", &IncompleteFormat);
30     EXPECT_FALSE(IncompleteFormat);
31     std::string Result = applyAllReplacements(Code, Replaces);
32     EXPECT_NE("", Result);
33     DEBUG(llvm::errs() << "\n" << Result << "\n\n");
34     return Result;
35   }
36 
37   static std::string format(
38       llvm::StringRef Code,
39       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
40     return format(Code, 0, Code.size(), Style);
41   }
42 
43   static FormatStyle getGoogleJSStyleWithColumns(unsigned ColumnLimit) {
44     FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
45     Style.ColumnLimit = ColumnLimit;
46     return Style;
47   }
48 
49   static void verifyFormat(
50       llvm::StringRef Code,
51       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
52     std::string result = format(test::messUp(Code), Style);
53     EXPECT_EQ(Code.str(), result) << "Formatted:\n" << result;
54   }
55 };
56 
57 TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
58   verifyFormat("a == = b;");
59   verifyFormat("a != = b;");
60 
61   verifyFormat("a === b;");
62   verifyFormat("aaaaaaa ===\n    b;", getGoogleJSStyleWithColumns(10));
63   verifyFormat("a !== b;");
64   verifyFormat("aaaaaaa !==\n    b;", getGoogleJSStyleWithColumns(10));
65   verifyFormat("if (a + b + c +\n"
66                "        d !==\n"
67                "    e + f + g)\n"
68                "  q();",
69                getGoogleJSStyleWithColumns(20));
70 
71   verifyFormat("a >> >= b;");
72 
73   verifyFormat("a >>> b;");
74   verifyFormat("aaaaaaa >>>\n    b;", getGoogleJSStyleWithColumns(10));
75   verifyFormat("a >>>= b;");
76   verifyFormat("aaaaaaa >>>=\n    b;", getGoogleJSStyleWithColumns(10));
77   verifyFormat("if (a + b + c +\n"
78                "        d >>>\n"
79                "    e + f + g)\n"
80                "  q();",
81                getGoogleJSStyleWithColumns(20));
82   verifyFormat("var x = aaaaaaaaaa ?\n"
83                "    bbbbbb :\n"
84                "    ccc;",
85                getGoogleJSStyleWithColumns(20));
86 
87   verifyFormat("var b = a.map((x) => x + 1);");
88   verifyFormat("return ('aaa') in bbbb;");
89 
90   // ES6 spread operator.
91   verifyFormat("someFunction(...a);");
92   verifyFormat("var x = [1, ...a, 2];");
93 }
94 
95 TEST_F(FormatTestJS, UnderstandsAmpAmp) {
96   verifyFormat("e && e.SomeFunction();");
97 }
98 
99 TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
100   verifyFormat("not.and.or.not_eq = 1;");
101 }
102 
103 TEST_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                "};");
114   verifyFormat("var struct = 2;");
115   verifyFormat("var union = 2;");
116 }
117 
118 TEST_F(FormatTestJS, CppKeywords) {
119   // Make sure we don't mess stuff up because of C++ keywords.
120   verifyFormat("return operator && (aa);");
121 }
122 
123 TEST_F(FormatTestJS, ES6DestructuringAssignment) {
124   verifyFormat("var [a, b, c] = [1, 2, 3];");
125   verifyFormat("let [a, b, c] = [1, 2, 3];");
126   verifyFormat("var {a, b} = {a: 1, b: 2};");
127   verifyFormat("let {a, b} = {a: 1, b: 2};");
128 }
129 
130 TEST_F(FormatTestJS, ContainerLiterals) {
131   verifyFormat("var x = {y: function(a) { return a; }};");
132   verifyFormat("return {\n"
133                "  link: function() {\n"
134                "    f();  //\n"
135                "  }\n"
136                "};");
137   verifyFormat("return {\n"
138                "  a: a,\n"
139                "  link: function() {\n"
140                "    f();  //\n"
141                "  }\n"
142                "};");
143   verifyFormat("return {\n"
144                "  a: a,\n"
145                "  link: function() {\n"
146                "    f();  //\n"
147                "  },\n"
148                "  link: function() {\n"
149                "    f();  //\n"
150                "  }\n"
151                "};");
152   verifyFormat("var stuff = {\n"
153                "  // comment for update\n"
154                "  update: false,\n"
155                "  // comment for modules\n"
156                "  modules: false,\n"
157                "  // comment for tasks\n"
158                "  tasks: false\n"
159                "};");
160   verifyFormat("return {\n"
161                "  'finish':\n"
162                "      //\n"
163                "      a\n"
164                "};");
165   verifyFormat("var obj = {\n"
166                "  fooooooooo: function(x) {\n"
167                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
168                "  }\n"
169                "};");
170   // Simple object literal, as opposed to enum style below.
171   verifyFormat("var obj = {a: 123};");
172   // Enum style top level assignment.
173   verifyFormat("X = {\n  a: 123\n};");
174   verifyFormat("X.Y = {\n  a: 123\n};");
175   // But only on the top level, otherwise its a plain object literal assignment.
176   verifyFormat("function x() {\n"
177                "  y = {z: 1};\n"
178                "}");
179   verifyFormat("x = foo && {a: 123};");
180 
181   // Arrow functions in object literals.
182   verifyFormat("var x = {y: (a) => { return a; }};");
183   verifyFormat("var x = {y: (a) => a};");
184 
185   // Computed keys.
186   verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
187   verifyFormat("var x = {\n"
188                "  [a]: 1,\n"
189                "  b: 2,\n"
190                "  [c]: 3,\n"
191                "};");
192 }
193 
194 TEST_F(FormatTestJS, MethodsInObjectLiterals) {
195   verifyFormat("var o = {\n"
196                "  value: 'test',\n"
197                "  get value() {  // getter\n"
198                "    return this.value;\n"
199                "  }\n"
200                "};");
201   verifyFormat("var o = {\n"
202                "  value: 'test',\n"
203                "  set value(val) {  // setter\n"
204                "    this.value = val;\n"
205                "  }\n"
206                "};");
207   verifyFormat("var o = {\n"
208                "  value: 'test',\n"
209                "  someMethod(val) {  // method\n"
210                "    doSomething(this.value + val);\n"
211                "  }\n"
212                "};");
213   verifyFormat("var o = {\n"
214                "  someMethod(val) {  // method\n"
215                "    doSomething(this.value + val);\n"
216                "  },\n"
217                "  someOtherMethod(val) {  // method\n"
218                "    doSomething(this.value + val);\n"
219                "  }\n"
220                "};");
221 }
222 
223 TEST_F(FormatTestJS, SpacesInContainerLiterals) {
224   verifyFormat("var arr = [1, 2, 3];");
225   verifyFormat("f({a: 1, b: 2, c: 3});");
226 
227   verifyFormat("var object_literal_with_long_name = {\n"
228                "  a: 'aaaaaaaaaaaaaaaaaa',\n"
229                "  b: 'bbbbbbbbbbbbbbbbbb'\n"
230                "};");
231 
232   verifyFormat("f({a: 1, b: 2, c: 3});",
233                getChromiumStyle(FormatStyle::LK_JavaScript));
234   verifyFormat("f({'a': [{}]});");
235 }
236 
237 TEST_F(FormatTestJS, SingleQuoteStrings) {
238   verifyFormat("this.function('', true);");
239 }
240 
241 TEST_F(FormatTestJS, GoogScopes) {
242   verifyFormat("goog.scope(function() {\n"
243                "var x = a.b;\n"
244                "var y = c.d;\n"
245                "});  // goog.scope");
246   verifyFormat("goog.scope(function() {\n"
247                "// test\n"
248                "var x = 0;\n"
249                "// test\n"
250                "});");
251 }
252 
253 TEST_F(FormatTestJS, GoogModules) {
254   verifyFormat("goog.module('this.is.really.absurdly.long');",
255                getGoogleJSStyleWithColumns(40));
256   verifyFormat("goog.require('this.is.really.absurdly.long');",
257                getGoogleJSStyleWithColumns(40));
258   verifyFormat("goog.provide('this.is.really.absurdly.long');",
259                getGoogleJSStyleWithColumns(40));
260   verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
261                getGoogleJSStyleWithColumns(40));
262   verifyFormat("goog.setTestOnly('this.is.really.absurdly.long');",
263                getGoogleJSStyleWithColumns(40));
264 
265   // These should be wrapped normally.
266   verifyFormat(
267       "var MyLongClassName =\n"
268       "    goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
269 }
270 
271 TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
272   verifyFormat("function outer1(a, b) {\n"
273                "  function inner1(a, b) { return a; }\n"
274                "  inner1(a, b);\n"
275                "}\n"
276                "function outer2(a, b) {\n"
277                "  function inner2(a, b) { return a; }\n"
278                "  inner2(a, b);\n"
279                "}");
280   verifyFormat("function f() {}");
281 }
282 
283 TEST_F(FormatTestJS, ArrayLiterals) {
284   verifyFormat("var aaaaa: List<SomeThing> =\n"
285                "    [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
286   verifyFormat("return [\n"
287                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
288                "  bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
289                "  ccccccccccccccccccccccccccc\n"
290                "];");
291   verifyFormat("return [\n"
292                "  aaaa().bbbbbbbb('A'),\n"
293                "  aaaa().bbbbbbbb('B'),\n"
294                "  aaaa().bbbbbbbb('C'),\n"
295                "];");
296   verifyFormat("var someVariable = SomeFunction([\n"
297                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
298                "  bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
299                "  ccccccccccccccccccccccccccc\n"
300                "]);");
301   verifyFormat("var someVariable = SomeFunction([\n"
302                "  [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
303                "]);",
304                getGoogleJSStyleWithColumns(51));
305   verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
306                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
307                "  bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
308                "  ccccccccccccccccccccccccccc\n"
309                "]);");
310   verifyFormat("var someVariable = SomeFunction(\n"
311                "    aaaa,\n"
312                "    [\n"
313                "      aaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
314                "      bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
315                "      ccccccccccccccccccccccccccc\n"
316                "    ],\n"
317                "    aaaa);");
318   verifyFormat("var aaaa = aaaaa ||  // wrap\n"
319                "    [];");
320 
321   verifyFormat("someFunction([], {a: a});");
322 }
323 
324 TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
325   verifyFormat("var array = [\n"
326                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
327                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
328                "];");
329   verifyFormat("var array = someFunction([\n"
330                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
331                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
332                "]);");
333 }
334 
335 TEST_F(FormatTestJS, FunctionLiterals) {
336   verifyFormat("doFoo(function() {});");
337   verifyFormat("doFoo(function() { return 1; });");
338   verifyFormat("var func = function() {\n"
339                "  return 1;\n"
340                "};");
341   verifyFormat("var func =  //\n"
342                "    function() {\n"
343                "  return 1;\n"
344                "};");
345   verifyFormat("return {\n"
346                "  body: {\n"
347                "    setAttribute: function(key, val) { this[key] = val; },\n"
348                "    getAttribute: function(key) { return this[key]; },\n"
349                "    style: {direction: ''}\n"
350                "  }\n"
351                "};");
352   verifyFormat("abc = xyz ? function() {\n"
353                "  return 1;\n"
354                "} : function() {\n"
355                "  return -1;\n"
356                "};");
357 
358   verifyFormat("var closure = goog.bind(\n"
359                "    function() {  // comment\n"
360                "      foo();\n"
361                "      bar();\n"
362                "    },\n"
363                "    this, arg1IsReallyLongAndNeeedsLineBreaks,\n"
364                "    arg3IsReallyLongAndNeeedsLineBreaks);");
365   verifyFormat("var closure = goog.bind(function() {  // comment\n"
366                "  foo();\n"
367                "  bar();\n"
368                "}, this);");
369   verifyFormat("return {\n"
370                "  a: 'E',\n"
371                "  b: function() {\n"
372                "    return function() {\n"
373                "      f();  //\n"
374                "    };\n"
375                "  }\n"
376                "};");
377   verifyFormat("{\n"
378                "  var someVariable = function(x) {\n"
379                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
380                "  };\n"
381                "}");
382   verifyFormat("someLooooooooongFunction(\n"
383                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
384                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
385                "    function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
386                "      // code\n"
387                "    });");
388 
389   verifyFormat("f({a: function() { return 1; }});",
390                getGoogleJSStyleWithColumns(33));
391   verifyFormat("f({\n"
392                "  a: function() { return 1; }\n"
393                "});",
394                getGoogleJSStyleWithColumns(32));
395 
396   verifyFormat("return {\n"
397                "  a: function SomeFunction() {\n"
398                "    // ...\n"
399                "    return 1;\n"
400                "  }\n"
401                "};");
402   verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
403                "    .then(goog.bind(function(aaaaaaaaaaa) {\n"
404                "      someFunction();\n"
405                "      someFunction();\n"
406                "    }, this), aaaaaaaaaaaaaaaaa);");
407 
408   verifyFormat("someFunction(goog.bind(function() {\n"
409                "  doSomething();\n"
410                "  doSomething();\n"
411                "}, this), goog.bind(function() {\n"
412                "  doSomething();\n"
413                "  doSomething();\n"
414                "}, this));");
415 
416   // FIXME: This is bad, we should be wrapping before "function() {".
417   verifyFormat("someFunction(function() {\n"
418                "  doSomething();  // break\n"
419                "})\n"
420                "    .doSomethingElse(\n"
421                "        // break\n"
422                "        );");
423 }
424 
425 TEST_F(FormatTestJS, InliningFunctionLiterals) {
426   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
427   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
428   verifyFormat("var func = function() {\n"
429                "  return 1;\n"
430                "};",
431                Style);
432   verifyFormat("var func = doSomething(function() { return 1; });", Style);
433   verifyFormat("var outer = function() {\n"
434                "  var inner = function() { return 1; }\n"
435                "};",
436                Style);
437   verifyFormat("function outer1(a, b) {\n"
438                "  function inner1(a, b) { return a; }\n"
439                "}",
440                Style);
441 
442   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
443   verifyFormat("var func = function() { return 1; };", Style);
444   verifyFormat("var func = doSomething(function() { return 1; });", Style);
445   verifyFormat(
446       "var outer = function() { var inner = function() { return 1; } };",
447       Style);
448   verifyFormat("function outer1(a, b) {\n"
449                "  function inner1(a, b) { return a; }\n"
450                "}",
451                Style);
452 
453   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
454   verifyFormat("var func = function() {\n"
455                "  return 1;\n"
456                "};",
457                Style);
458   verifyFormat("var func = doSomething(function() {\n"
459                "  return 1;\n"
460                "});",
461                Style);
462   verifyFormat("var outer = function() {\n"
463                "  var inner = function() {\n"
464                "    return 1;\n"
465                "  }\n"
466                "};",
467                Style);
468   verifyFormat("function outer1(a, b) {\n"
469                "  function inner1(a, b) {\n"
470                "    return a;\n"
471                "  }\n"
472                "}",
473                Style);
474 
475   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
476   verifyFormat("var func = function() {\n"
477                "  return 1;\n"
478                "};",
479                Style);
480 }
481 
482 TEST_F(FormatTestJS, MultipleFunctionLiterals) {
483   verifyFormat("promise.then(\n"
484                "    function success() {\n"
485                "      doFoo();\n"
486                "      doBar();\n"
487                "    },\n"
488                "    function error() {\n"
489                "      doFoo();\n"
490                "      doBaz();\n"
491                "    },\n"
492                "    []);\n");
493   verifyFormat("promise.then(\n"
494                "    function success() {\n"
495                "      doFoo();\n"
496                "      doBar();\n"
497                "    },\n"
498                "    [],\n"
499                "    function error() {\n"
500                "      doFoo();\n"
501                "      doBaz();\n"
502                "    });\n");
503   verifyFormat("promise.then(\n"
504                "    [],\n"
505                "    function success() {\n"
506                "      doFoo();\n"
507                "      doBar();\n"
508                "    },\n"
509                "    function error() {\n"
510                "      doFoo();\n"
511                "      doBaz();\n"
512                "    });\n");
513 
514   verifyFormat("getSomeLongPromise()\n"
515                "    .then(function(value) { body(); })\n"
516                "    .thenCatch(function(error) {\n"
517                "      body();\n"
518                "      body();\n"
519                "    });");
520   verifyFormat("getSomeLongPromise()\n"
521                "    .then(function(value) {\n"
522                "      body();\n"
523                "      body();\n"
524                "    })\n"
525                "    .thenCatch(function(error) {\n"
526                "      body();\n"
527                "      body();\n"
528                "    });");
529 
530   verifyFormat("getSomeLongPromise()\n"
531                "    .then(function(value) { body(); })\n"
532                "    .thenCatch(function(error) { body(); });");
533 
534   verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
535                "    .aaaaaaa(function() {\n"
536                "      //\n"
537                "    })\n"
538                "    .bbbbbb();");
539 }
540 
541 TEST_F(FormatTestJS, ArrowFunctions) {
542   verifyFormat("var x = (a) => {\n"
543                "  return a;\n"
544                "};");
545   verifyFormat("var x = (a) => {\n"
546                "  function y() { return 42; }\n"
547                "  return a;\n"
548                "};");
549   verifyFormat("var x = (a: type): {some: type} => {\n"
550                "  return a;\n"
551                "};");
552   verifyFormat("var x = (a) => a;");
553   verifyFormat("return () => [];");
554   verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
555                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
556                "      (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
557                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
558                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
559                "};");
560   verifyFormat("var a = a.aaaaaaa(\n"
561                "    (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
562                "        aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
563   verifyFormat("var a = a.aaaaaaa(\n"
564                "    (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
565                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
566                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
567 
568   // FIXME: This is bad, we should be wrapping before "() => {".
569   verifyFormat("someFunction(() => {\n"
570                "  doSomething();  // break\n"
571                "})\n"
572                "    .doSomethingElse(\n"
573                "        // break\n"
574                "        );");
575 }
576 
577 TEST_F(FormatTestJS, ReturnStatements) {
578   verifyFormat("function() {\n"
579                "  return [hello, world];\n"
580                "}");
581 }
582 
583 TEST_F(FormatTestJS, ForLoops) {
584   verifyFormat("for (var i in [2, 3]) {\n"
585                "}");
586 }
587 
588 TEST_F(FormatTestJS, AutomaticSemicolonInsertion) {
589   // The following statements must not wrap, as otherwise the program meaning
590   // would change due to automatic semicolon insertion.
591   // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
592   verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
593   verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
594   verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
595   verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
596   verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
597   verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
598 }
599 
600 TEST_F(FormatTestJS, ClosureStyleCasts) {
601   verifyFormat("var x = /** @type {foo} */ (bar);");
602 }
603 
604 TEST_F(FormatTestJS, TryCatch) {
605   verifyFormat("try {\n"
606                "  f();\n"
607                "} catch (e) {\n"
608                "  g();\n"
609                "} finally {\n"
610                "  h();\n"
611                "}");
612 
613   // But, of course, "catch" is a perfectly fine function name in JavaScript.
614   verifyFormat("someObject.catch();");
615   verifyFormat("someObject.new();");
616   verifyFormat("someObject.delete();");
617 }
618 
619 TEST_F(FormatTestJS, StringLiteralConcatenation) {
620   verifyFormat("var literal = 'hello ' +\n"
621                "    'world';");
622 }
623 
624 TEST_F(FormatTestJS, RegexLiteralClassification) {
625   // Regex literals.
626   verifyFormat("var regex = /abc/;");
627   verifyFormat("f(/abc/);");
628   verifyFormat("f(abc, /abc/);");
629   verifyFormat("some_map[/abc/];");
630   verifyFormat("var x = a ? /abc/ : /abc/;");
631   verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
632   verifyFormat("var x = !/abc/.test(y);");
633   verifyFormat("var x = a && /abc/.test(y);");
634   verifyFormat("var x = a || /abc/.test(y);");
635   verifyFormat("var x = a + /abc/.search(y);");
636   verifyFormat("/abc/.search(y);");
637   verifyFormat("var regexs = {/abc/, /abc/};");
638   verifyFormat("return /abc/;");
639 
640   // Not regex literals.
641   verifyFormat("var a = a / 2 + b / 3;");
642   verifyFormat("var a = a++ / 2;");
643   // Prefix unary can operate on regex literals, not that it makes sense.
644   verifyFormat("var a = ++/a/;");
645 
646   // This is a known issue, regular expressions are incorrectly detected if
647   // directly following a closing parenthesis.
648   verifyFormat("if (foo) / bar /.exec(baz);");
649 }
650 
651 TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
652   verifyFormat("var regex = /=/;");
653   verifyFormat("var regex = /a*/;");
654   verifyFormat("var regex = /a+/;");
655   verifyFormat("var regex = /a?/;");
656   verifyFormat("var regex = /.a./;");
657   verifyFormat("var regex = /a\\*/;");
658   verifyFormat("var regex = /^a$/;");
659   verifyFormat("var regex = /\\/a/;");
660   verifyFormat("var regex = /(?:x)/;");
661   verifyFormat("var regex = /x(?=y)/;");
662   verifyFormat("var regex = /x(?!y)/;");
663   verifyFormat("var regex = /x|y/;");
664   verifyFormat("var regex = /a{2}/;");
665   verifyFormat("var regex = /a{1,3}/;");
666 
667   verifyFormat("var regex = /[abc]/;");
668   verifyFormat("var regex = /[^abc]/;");
669   verifyFormat("var regex = /[\\b]/;");
670   verifyFormat("var regex = /[/]/;");
671   verifyFormat("var regex = /[\\/]/;");
672   verifyFormat("var regex = /\\[/;");
673   verifyFormat("var regex = /\\\\[/]/;");
674   verifyFormat("var regex = /}[\"]/;");
675   verifyFormat("var regex = /}[/\"]/;");
676   verifyFormat("var regex = /}[\"/]/;");
677 
678   verifyFormat("var regex = /\\b/;");
679   verifyFormat("var regex = /\\B/;");
680   verifyFormat("var regex = /\\d/;");
681   verifyFormat("var regex = /\\D/;");
682   verifyFormat("var regex = /\\f/;");
683   verifyFormat("var regex = /\\n/;");
684   verifyFormat("var regex = /\\r/;");
685   verifyFormat("var regex = /\\s/;");
686   verifyFormat("var regex = /\\S/;");
687   verifyFormat("var regex = /\\t/;");
688   verifyFormat("var regex = /\\v/;");
689   verifyFormat("var regex = /\\w/;");
690   verifyFormat("var regex = /\\W/;");
691   verifyFormat("var regex = /a(a)\\1/;");
692   verifyFormat("var regex = /\\0/;");
693   verifyFormat("var regex = /\\\\/g;");
694   verifyFormat("var regex = /\\a\\\\/g;");
695   verifyFormat("var regex = /\a\\//g;");
696   verifyFormat("var regex = /a\\//;\n"
697                "var x = 0;");
698   EXPECT_EQ("var regex = /'/g;", format("var regex = /'/g ;"));
699   EXPECT_EQ("var regex = /'/g;  //'", format("var regex = /'/g ; //'"));
700   EXPECT_EQ("var regex = /\\/*/;\n"
701             "var x = 0;",
702             format("var regex = /\\/*/;\n"
703                    "var x=0;"));
704   EXPECT_EQ("var x = /a\\//;", format("var x = /a\\//  \n;"));
705   verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
706   verifyFormat("var regex =\n"
707                "    /\"/;",
708                getGoogleJSStyleWithColumns(15));
709   verifyFormat("var regex =  //\n"
710                "    /a/;");
711   verifyFormat("var regexs = [\n"
712                "  /d/,   //\n"
713                "  /aa/,  //\n"
714                "];");
715 }
716 
717 TEST_F(FormatTestJS, RegexLiteralModifiers) {
718   verifyFormat("var regex = /abc/g;");
719   verifyFormat("var regex = /abc/i;");
720   verifyFormat("var regex = /abc/m;");
721   verifyFormat("var regex = /abc/y;");
722 }
723 
724 TEST_F(FormatTestJS, RegexLiteralLength) {
725   verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
726                getGoogleJSStyleWithColumns(60));
727   verifyFormat("var regex =\n"
728                "    /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
729                getGoogleJSStyleWithColumns(60));
730   verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
731                getGoogleJSStyleWithColumns(50));
732 }
733 
734 TEST_F(FormatTestJS, RegexLiteralExamples) {
735   verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
736 }
737 
738 TEST_F(FormatTestJS, TypeAnnotations) {
739   verifyFormat("var x: string;");
740   verifyFormat("var x: {a: string; b: number;} = {};");
741   verifyFormat("function x(): string {\n  return 'x';\n}");
742   verifyFormat("function x(): {x: string} {\n  return {x: 'x'};\n}");
743   verifyFormat("function x(y: string): string {\n  return 'x';\n}");
744   verifyFormat("for (var y: string in x) {\n  x();\n}");
745   verifyFormat("function x(y: {a?: number;} = {}): number {\n"
746                "  return 12;\n"
747                "}");
748   verifyFormat("((a: string, b: number): string => a + b);");
749   verifyFormat("var x: (y: number) => string;");
750   verifyFormat("var x: P<string, (a: number) => string>;");
751   verifyFormat("var x = {y: function(): z { return 1; }};");
752   verifyFormat("var x = {y: function(): {a: number} { return 1; }};");
753   verifyFormat("function someFunc(args: string[]):\n"
754                "    {longReturnValue: string[]} {}",
755                getGoogleJSStyleWithColumns(60));
756 }
757 
758 TEST_F(FormatTestJS, ClassDeclarations) {
759   verifyFormat("class C {\n  x: string = 12;\n}");
760   verifyFormat("class C {\n  x(): string => 12;\n}");
761   verifyFormat("class C {\n  ['x' + 2]: string = 12;\n}");
762   verifyFormat("class C {\n  private x: string = 12;\n}");
763   verifyFormat("class C {\n  private static x: string = 12;\n}");
764   verifyFormat("class C {\n  static x(): string { return 'asd'; }\n}");
765   verifyFormat("class C extends P implements I {}");
766   verifyFormat("class C extends p.P implements i.I {}");
767   verifyFormat("class Test {\n"
768                "  aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
769                "      aaaaaaaaaaaaaaaaaaaaaa {}\n"
770                "}");
771   verifyFormat("foo = class Name {\n"
772                "  constructor() {}\n"
773                "};");
774   verifyFormat("foo = class {\n"
775                "  constructor() {}\n"
776                "};");
777   verifyFormat("class C {\n"
778                "  x: {y: Z;} = {};\n"
779                "  private y: {y: Z;} = {};\n"
780                "}");
781 
782   // ':' is not a type declaration here.
783   verifyFormat("class X {\n"
784                "  subs = {\n"
785                "    'b': {\n"
786                "      'c': 1,\n"
787                "    },\n"
788                "  };\n"
789                "}");
790 }
791 
792 TEST_F(FormatTestJS, InterfaceDeclarations) {
793   verifyFormat("interface I {\n"
794                "  x: string;\n"
795                "  enum: string[];\n"
796                "}\n"
797                "var y;");
798   // Ensure that state is reset after parsing the interface.
799   verifyFormat("interface a {}\n"
800                "export function b() {}\n"
801                "var x;");
802 
803   // Arrays of object type literals.
804   verifyFormat("interface I {\n"
805                "  o: {}[];\n"
806                "}");
807 }
808 
809 TEST_F(FormatTestJS, EnumDeclarations) {
810   verifyFormat("enum Foo {\n"
811                "  A = 1,\n"
812                "  B\n"
813                "}");
814   verifyFormat("export /* somecomment*/ enum Foo {\n"
815                "  A = 1,\n"
816                "  B\n"
817                "}");
818   verifyFormat("enum Foo {\n"
819                "  A = 1,  // comment\n"
820                "  B\n"
821                "}\n"
822                "var x = 1;");
823 }
824 
825 TEST_F(FormatTestJS, MetadataAnnotations) {
826   verifyFormat("@A\nclass C {\n}");
827   verifyFormat("@A({arg: 'value'})\nclass C {\n}");
828   verifyFormat("@A\n@B\nclass C {\n}");
829   verifyFormat("class C {\n  @A x: string;\n}");
830   verifyFormat("class C {\n"
831                "  @A\n"
832                "  private x(): string {\n"
833                "    return 'y';\n"
834                "  }\n"
835                "}");
836   verifyFormat("class X {}\n"
837                "class Y {}");
838 }
839 
840 TEST_F(FormatTestJS, Modules) {
841   verifyFormat("import SomeThing from 'some/module.js';");
842   verifyFormat("import {X, Y} from 'some/module.js';");
843   verifyFormat("import a, {X, Y} from 'some/module.js';");
844   verifyFormat("import {\n"
845                "  VeryLongImportsAreAnnoying,\n"
846                "  VeryLongImportsAreAnnoying,\n"
847                "  VeryLongImportsAreAnnoying,\n"
848                "  VeryLongImportsAreAnnoying\n"
849                "} from 'some/module.js';");
850   verifyFormat("import {\n"
851                "  X,\n"
852                "  Y,\n"
853                "} from 'some/module.js';");
854   verifyFormat("import {\n"
855                "  X,\n"
856                "  Y,\n"
857                "} from 'some/long/module.js';",
858                getGoogleJSStyleWithColumns(20));
859   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
860   verifyFormat("import * as lib from 'some/module.js';");
861   verifyFormat("var x = {import: 1};\nx.import = 2;");
862 
863   verifyFormat("export function fn() {\n"
864                "  return 'fn';\n"
865                "}");
866   verifyFormat("export function A() {}\n"
867                "export default function B() {}\n"
868                "export function C() {}");
869   verifyFormat("export const x = 12;");
870   verifyFormat("export default class X {}");
871   verifyFormat("export {X, Y} from 'some/module.js';");
872   verifyFormat("export {\n"
873                "  X,\n"
874                "  Y,\n"
875                "} from 'some/module.js';");
876   verifyFormat("export class C {\n"
877                "  x: number;\n"
878                "  y: string;\n"
879                "}");
880   verifyFormat("export class X { y: number; }");
881   verifyFormat("export default class X { y: number }");
882   verifyFormat("export default function() {\n  return 1;\n}");
883   verifyFormat("export var x = 12;");
884   verifyFormat("class C {}\n"
885                "export function f() {}\n"
886                "var v;");
887   verifyFormat("export var x: number = 12;");
888   verifyFormat("export const y = {\n"
889                "  a: 1,\n"
890                "  b: 2\n"
891                "};");
892   verifyFormat("export enum Foo {\n"
893                "  BAR,\n"
894                "  // adsdasd\n"
895                "  BAZ\n"
896                "}");
897   verifyFormat("export default [\n"
898                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
899                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
900                "];");
901   verifyFormat("export default [];");
902   verifyFormat("export default () => {};");
903   verifyFormat("export interface Foo { foo: number; }\n"
904                "export class Bar {\n"
905                "  blah(): string { return this.blah; };\n"
906                "}");
907 }
908 
909 TEST_F(FormatTestJS, TemplateStrings) {
910   // Keeps any whitespace/indentation within the template string.
911   EXPECT_EQ("var x = `hello\n"
912             "     ${  name    }\n"
913             "  !`;",
914             format("var x    =    `hello\n"
915                    "     ${  name    }\n"
916                    "  !`;"));
917 
918   verifyFormat("var x =\n"
919                "    `hello ${world}` >= some();",
920                getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
921   verifyFormat("var x = `hello ${world}` >= some();",
922                getGoogleJSStyleWithColumns(35)); // Barely fits.
923   EXPECT_EQ("var x = `hello\n"
924             "  ${world}` >=\n"
925             "    some();",
926             format("var x =\n"
927                    "    `hello\n"
928                    "  ${world}` >= some();",
929                    getGoogleJSStyleWithColumns(21))); // Barely doesn't fit.
930   EXPECT_EQ("var x = `hello\n"
931             "  ${world}` >= some();",
932             format("var x =\n"
933                    "    `hello\n"
934                    "  ${world}` >= some();",
935                    getGoogleJSStyleWithColumns(22))); // Barely fits.
936 
937   verifyFormat("var x =\n"
938                "    `h`;",
939                getGoogleJSStyleWithColumns(11));
940   EXPECT_EQ(
941       "var x =\n    `multi\n  line`;",
942       format("var x = `multi\n  line`;", getGoogleJSStyleWithColumns(13)));
943   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
944                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
945 
946   // Make sure template strings get a proper ColumnWidth assigned, even if they
947   // are first token in line.
948   verifyFormat(
949       "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
950       "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
951 
952   // Two template strings.
953   verifyFormat("var x = `hello` == `hello`;");
954 
955   // Comments in template strings.
956   EXPECT_EQ("var x = `//a`;\n"
957             "var y;",
958             format("var x =\n `//a`;\n"
959                    "var y  ;"));
960   EXPECT_EQ("var x = `/*a`;\n"
961             "var y;",
962             format("var x =\n `/*a`;\n"
963                    "var y;"));
964   // Unterminated string literals in a template string.
965   verifyFormat("var x = `'`;  // comment with matching quote '\n"
966                "var y;");
967   verifyFormat("var x = `\"`;  // comment with matching quote \"\n"
968                "var y;");
969   EXPECT_EQ("it(`'aaaaaaaaaaaaaaa   `, aaaaaaaaa);",
970             format("it(`'aaaaaaaaaaaaaaa   `,   aaaaaaaaa) ;",
971                    getGoogleJSStyleWithColumns(40)));
972   // Backticks in a comment - not a template string.
973   EXPECT_EQ("var x = 1  // `/*a`;\n"
974             "    ;",
975             format("var x =\n 1  // `/*a`;\n"
976                    "    ;"));
977   EXPECT_EQ("/* ` */ var x = 1; /* ` */",
978             format("/* ` */ var x\n= 1; /* ` */"));
979   // Comment spans multiple template strings.
980   EXPECT_EQ("var x = `/*a`;\n"
981             "var y = ` */ `;",
982             format("var x =\n `/*a`;\n"
983                    "var y =\n ` */ `;"));
984   // Escaped backtick.
985   EXPECT_EQ("var x = ` \\` a`;\n"
986             "var y;",
987             format("var x = ` \\` a`;\n"
988                    "var y;"));
989 }
990 
991 TEST_F(FormatTestJS, CastSyntax) { verifyFormat("var x = <type>foo;"); }
992 
993 TEST_F(FormatTestJS, TypeArguments) {
994   verifyFormat("class X<Y> {}");
995   verifyFormat("new X<Y>();");
996   verifyFormat("foo<Y>(a);");
997   verifyFormat("var x: X<Y>[];");
998   verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
999   verifyFormat("function f(a: List<any> = null) {}");
1000   verifyFormat("function f(): List<any> {}");
1001   verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1002                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
1003   verifyFormat("function aaaaaaaaaa(\n"
1004                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1005                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
1006                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
1007 }
1008 
1009 TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1010   verifyFormat(
1011       "function foo(check: Object):\n"
1012       "    check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1013       "  return 'bar' in check;\n"
1014       "}\n");
1015 }
1016 
1017 TEST_F(FormatTestJS, OptionalTypes) {
1018   verifyFormat("function x(a?: b, c?, d?) {}");
1019   verifyFormat("class X {\n"
1020                "  y?: z;\n"
1021                "  z?;\n"
1022                "}");
1023   verifyFormat("interface X {\n"
1024                "  y?(): z;\n"
1025                "}");
1026   verifyFormat("x ? 1 : 2;");
1027   verifyFormat("constructor({aa}: {\n"
1028                "  aa?: string,\n"
1029                "  aaaaaaaa?: string,\n"
1030                "  aaaaaaaaaaaaaaa?: boolean,\n"
1031                "  aaaaaa?: List<string>\n"
1032                "}) {}");
1033 }
1034 
1035 TEST_F(FormatTestJS, IndexSignature) {
1036   verifyFormat("var x: {[k: string]: v};");
1037 }
1038 
1039 TEST_F(FormatTestJS, WrapAfterParen) {
1040   verifyFormat("xxxxxxxxxxx(\n"
1041                "    aaa, aaa);",
1042                getGoogleJSStyleWithColumns(20));
1043   verifyFormat("xxxxxxxxxxx(\n"
1044                "    aaa, aaa, aaa,\n"
1045                "    aaa, aaa, aaa);",
1046                getGoogleJSStyleWithColumns(20));
1047   verifyFormat("xxxxxxxxxxx(\n"
1048                "    aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1049                "    function(x) {\n"
1050                "      y();  //\n"
1051                "    });",
1052                getGoogleJSStyleWithColumns(40));
1053   verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1054                "       bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1055 }
1056 
1057 TEST_F(FormatTestJS, JSDocAnnotations) {
1058   EXPECT_EQ("/**\n"
1059             " * @export {this.is.a.long.path.to.a.Type}\n"
1060             " */",
1061             format("/**\n"
1062                    " * @export {this.is.a.long.path.to.a.Type}\n"
1063                    " */",
1064                    getGoogleJSStyleWithColumns(20)));
1065 }
1066 
1067 } // end namespace tooling
1068 } // end namespace clang
1069