xref: /llvm-project/clang/unittests/Format/FormatTestJS.cpp (revision a004b3f50f3e8fd097f481f531439e783d8b54d6)
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     FormattingAttemptStatus Status;
28     tooling::Replacements Replaces =
29         reformat(Style, Code, Ranges, "<stdin>", &Status);
30     EXPECT_TRUE(Status.FormatComplete);
31     auto Result = applyAllReplacements(Code, Replaces);
32     EXPECT_TRUE(static_cast<bool>(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   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;
62   }
63 };
64 
65 TEST_F(FormatTestJS, BlockComments) {
66   verifyFormat("/* aaaaaaaaaaaaa */ aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
67                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
68   // Breaks after a single line block comment.
69   EXPECT_EQ("aaaaa = bbbb.ccccccccccccccc(\n"
70             "    /** @type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala} */\n"
71             "    mediaMessage);",
72             format("aaaaa = bbbb.ccccccccccccccc(\n"
73                    "    /** "
74                    "@type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala} */ "
75                    "mediaMessage);",
76                    getGoogleJSStyleWithColumns(70)));
77   // Breaks after a multiline block comment.
78   EXPECT_EQ(
79       "aaaaa = bbbb.ccccccccccccccc(\n"
80       "    /**\n"
81       "     * @type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala}\n"
82       "     */\n"
83       "    mediaMessage);",
84       format("aaaaa = bbbb.ccccccccccccccc(\n"
85              "    /**\n"
86              "     * @type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala}\n"
87              "     */ mediaMessage);",
88              getGoogleJSStyleWithColumns(70)));
89 }
90 
91 TEST_F(FormatTestJS, JSDocComments) {
92   // Break the first line of a multiline jsdoc comment.
93   EXPECT_EQ("/**\n"
94             " * jsdoc line 1\n"
95             " * jsdoc line 2\n"
96             " */",
97             format("/** jsdoc line 1\n"
98                    " * jsdoc line 2\n"
99                    " */",
100                    getGoogleJSStyleWithColumns(20)));
101   // Both break after '/**' and break the line itself.
102   EXPECT_EQ("/**\n"
103             " * jsdoc line long\n"
104             " * long jsdoc line 2\n"
105             " */",
106             format("/** jsdoc line long long\n"
107                    " * jsdoc line 2\n"
108                    " */",
109                    getGoogleJSStyleWithColumns(20)));
110   // Break a short first line if the ending '*/' is on a newline.
111   EXPECT_EQ("/**\n"
112             " * jsdoc line 1\n"
113             " */",
114             format("/** jsdoc line 1\n"
115                    " */", getGoogleJSStyleWithColumns(20)));
116   // Don't break the first line of a short single line jsdoc comment.
117   EXPECT_EQ("/** jsdoc line 1 */",
118             format("/** jsdoc line 1 */", getGoogleJSStyleWithColumns(20)));
119   // Don't break the first line of a single line jsdoc comment if it just fits
120   // the column limit.
121   EXPECT_EQ("/** jsdoc line 12 */",
122             format("/** jsdoc line 12 */", getGoogleJSStyleWithColumns(20)));
123   // Don't break after '/**' and before '*/' if there is no space between
124   // '/**' and the content.
125   EXPECT_EQ(
126       "/*** nonjsdoc long\n"
127       " * line */",
128       format("/*** nonjsdoc long line */", getGoogleJSStyleWithColumns(20)));
129   EXPECT_EQ(
130       "/**strange long long\n"
131       " * line */",
132       format("/**strange long long line */", getGoogleJSStyleWithColumns(20)));
133   // Break the first line of a single line jsdoc comment if it just exceeds the
134   // column limit.
135   EXPECT_EQ("/**\n"
136             " * jsdoc line 123\n"
137             " */",
138             format("/** jsdoc line 123 */", getGoogleJSStyleWithColumns(20)));
139   // Break also if the leading indent of the first line is more than 1 column.
140   EXPECT_EQ("/**\n"
141             " * jsdoc line 123\n"
142             " */",
143             format("/**  jsdoc line 123 */", getGoogleJSStyleWithColumns(20)));
144   // Break also if the leading indent of the first line is more than 1 column.
145   EXPECT_EQ("/**\n"
146             " * jsdoc line 123\n"
147             " */",
148             format("/**   jsdoc line 123 */", getGoogleJSStyleWithColumns(20)));
149   // Break after the content of the last line.
150   EXPECT_EQ("/**\n"
151             " * line 1\n"
152             " * line 2\n"
153             " */",
154             format("/**\n"
155                    " * line 1\n"
156                    " * line 2 */",
157                    getGoogleJSStyleWithColumns(20)));
158   // Break both the content and after the content of the last line.
159   EXPECT_EQ("/**\n"
160             " * line 1\n"
161             " * line long long\n"
162             " * long\n"
163             " */",
164             format("/**\n"
165                    " * line 1\n"
166                    " * line long long long */",
167                    getGoogleJSStyleWithColumns(20)));
168 
169   // The comment block gets indented.
170   EXPECT_EQ("function f() {\n"
171             "  /**\n"
172             "   * comment about\n"
173             "   * x\n"
174             "   */\n"
175             "  var x = 1;\n"
176             "}",
177             format("function f() {\n"
178                    "/** comment about x */\n"
179                    "var x = 1;\n"
180                    "}",
181                    getGoogleJSStyleWithColumns(20)));
182 
183   // Don't break the first line of a single line short jsdoc comment pragma.
184   EXPECT_EQ("/** @returns j */",
185             format("/** @returns j */",
186                    getGoogleJSStyleWithColumns(20)));
187 
188   // Break a single line long jsdoc comment pragma.
189   EXPECT_EQ("/**\n"
190             " * @returns {string} jsdoc line 12\n"
191             " */",
192             format("/** @returns {string} jsdoc line 12 */",
193                    getGoogleJSStyleWithColumns(20)));
194 
195   EXPECT_EQ("/**\n"
196             " * @returns {string} jsdoc line 12\n"
197             " */",
198             format("/** @returns {string} jsdoc line 12  */",
199                    getGoogleJSStyleWithColumns(20)));
200 
201   EXPECT_EQ("/**\n"
202             " * @returns {string} jsdoc line 12\n"
203             " */",
204             format("/** @returns {string} jsdoc line 12*/",
205                    getGoogleJSStyleWithColumns(20)));
206 
207   // Fix a multiline jsdoc comment ending in a comment pragma.
208   EXPECT_EQ("/**\n"
209             " * line 1\n"
210             " * line 2\n"
211             " * @returns {string} jsdoc line 12\n"
212             " */",
213             format("/** line 1\n"
214                    " * line 2\n"
215                    " * @returns {string} jsdoc line 12 */",
216                    getGoogleJSStyleWithColumns(20)));
217 
218   EXPECT_EQ("/**\n"
219             " * line 1\n"
220             " * line 2\n"
221             " *\n"
222             " * @returns j\n"
223             " */",
224             format("/** line 1\n"
225                    " * line 2\n"
226                    " *\n"
227                    " * @returns j */",
228                    getGoogleJSStyleWithColumns(20)));
229 }
230 
231 TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
232   verifyFormat("a == = b;");
233   verifyFormat("a != = b;");
234 
235   verifyFormat("a === b;");
236   verifyFormat("aaaaaaa ===\n    b;", getGoogleJSStyleWithColumns(10));
237   verifyFormat("a !== b;");
238   verifyFormat("aaaaaaa !==\n    b;", getGoogleJSStyleWithColumns(10));
239   verifyFormat("if (a + b + c +\n"
240                "        d !==\n"
241                "    e + f + g)\n"
242                "  q();",
243                getGoogleJSStyleWithColumns(20));
244 
245   verifyFormat("a >> >= b;");
246 
247   verifyFormat("a >>> b;");
248   verifyFormat("aaaaaaa >>>\n    b;", getGoogleJSStyleWithColumns(10));
249   verifyFormat("a >>>= b;");
250   verifyFormat("aaaaaaa >>>=\n    b;", getGoogleJSStyleWithColumns(10));
251   verifyFormat("if (a + b + c +\n"
252                "        d >>>\n"
253                "    e + f + g)\n"
254                "  q();",
255                getGoogleJSStyleWithColumns(20));
256   verifyFormat("var x = aaaaaaaaaa ?\n"
257                "    bbbbbb :\n"
258                "    ccc;",
259                getGoogleJSStyleWithColumns(20));
260 
261   verifyFormat("var b = a.map((x) => x + 1);");
262   verifyFormat("return ('aaa') in bbbb;");
263   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
264                "    aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
265   FormatStyle Style = getGoogleJSStyleWithColumns(80);
266   Style.AlignOperands = true;
267   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
268                "        aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
269                Style);
270   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
271   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa()\n"
272                "            in aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
273                Style);
274 
275   // ES6 spread operator.
276   verifyFormat("someFunction(...a);");
277   verifyFormat("var x = [1, ...a, 2];");
278 }
279 
280 TEST_F(FormatTestJS, UnderstandsAmpAmp) {
281   verifyFormat("e && e.SomeFunction();");
282 }
283 
284 TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
285   verifyFormat("not.and.or.not_eq = 1;");
286 }
287 
288 TEST_F(FormatTestJS, ReservedWords) {
289   // JavaScript reserved words (aka keywords) are only illegal when used as
290   // Identifiers, but are legal as IdentifierNames.
291   verifyFormat("x.class.struct = 1;");
292   verifyFormat("x.case = 1;");
293   verifyFormat("x.interface = 1;");
294   verifyFormat("x.for = 1;");
295   verifyFormat("x.of();");
296   verifyFormat("of(null);");
297   verifyFormat("import {of} from 'x';");
298   verifyFormat("x.in();");
299   verifyFormat("x.let();");
300   verifyFormat("x.var();");
301   verifyFormat("x.for();");
302   verifyFormat("x.as();");
303   verifyFormat("x.instanceof();");
304   verifyFormat("x.switch();");
305   verifyFormat("x.case();");
306   verifyFormat("x.delete();");
307   verifyFormat("x.throw();");
308   verifyFormat("x.throws();");
309   verifyFormat("x.if();");
310   verifyFormat("x = {\n"
311                "  a: 12,\n"
312                "  interface: 1,\n"
313                "  switch: 1,\n"
314                "};");
315   verifyFormat("var struct = 2;");
316   verifyFormat("var union = 2;");
317   verifyFormat("var interface = 2;");
318   verifyFormat("interface = 2;");
319   verifyFormat("x = interface instanceof y;");
320   verifyFormat("interface Test {\n"
321                "  x: string;\n"
322                "  switch: string;\n"
323                "  case: string;\n"
324                "  default: string;\n"
325                "}\n");
326 }
327 
328 TEST_F(FormatTestJS, ReservedWordsMethods) {
329   verifyFormat(
330       "class X {\n"
331       "  delete() {\n"
332       "    x();\n"
333       "  }\n"
334       "  interface() {\n"
335       "    x();\n"
336       "  }\n"
337       "  let() {\n"
338       "    x();\n"
339       "  }\n"
340       "}\n");
341 }
342 
343 TEST_F(FormatTestJS, ReservedWordsParenthesized) {
344   // All of these are statements using the keyword, not function calls.
345   verifyFormat("throw (x + y);\n"
346                "await (await x).y;\n"
347                "typeof (x) === 'string';\n"
348                "void (0);\n"
349                "delete (x.y);\n"
350                "return (x);\n");
351 }
352 
353 TEST_F(FormatTestJS, CppKeywords) {
354   // Make sure we don't mess stuff up because of C++ keywords.
355   verifyFormat("return operator && (aa);");
356   // .. or QT ones.
357   verifyFormat("slots: Slot[];");
358 }
359 
360 TEST_F(FormatTestJS, ES6DestructuringAssignment) {
361   verifyFormat("var [a, b, c] = [1, 2, 3];");
362   verifyFormat("const [a, b, c] = [1, 2, 3];");
363   verifyFormat("let [a, b, c] = [1, 2, 3];");
364   verifyFormat("var {a, b} = {a: 1, b: 2};");
365   verifyFormat("let {a, b} = {a: 1, b: 2};");
366 }
367 
368 TEST_F(FormatTestJS, ContainerLiterals) {
369   verifyFormat("var x = {\n"
370                "  y: function(a) {\n"
371                "    return a;\n"
372                "  }\n"
373                "};");
374   verifyFormat("return {\n"
375                "  link: function() {\n"
376                "    f();  //\n"
377                "  }\n"
378                "};");
379   verifyFormat("return {\n"
380                "  a: a,\n"
381                "  link: function() {\n"
382                "    f();  //\n"
383                "  }\n"
384                "};");
385   verifyFormat("return {\n"
386                "  a: a,\n"
387                "  link: function() {\n"
388                "    f();  //\n"
389                "  },\n"
390                "  link: function() {\n"
391                "    f();  //\n"
392                "  }\n"
393                "};");
394   verifyFormat("var stuff = {\n"
395                "  // comment for update\n"
396                "  update: false,\n"
397                "  // comment for modules\n"
398                "  modules: false,\n"
399                "  // comment for tasks\n"
400                "  tasks: false\n"
401                "};");
402   verifyFormat("return {\n"
403                "  'finish':\n"
404                "      //\n"
405                "      a\n"
406                "};");
407   verifyFormat("var obj = {\n"
408                "  fooooooooo: function(x) {\n"
409                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
410                "  }\n"
411                "};");
412   // Simple object literal, as opposed to enum style below.
413   verifyFormat("var obj = {a: 123};");
414   // Enum style top level assignment.
415   verifyFormat("X = {\n  a: 123\n};");
416   verifyFormat("X.Y = {\n  a: 123\n};");
417   // But only on the top level, otherwise its a plain object literal assignment.
418   verifyFormat("function x() {\n"
419                "  y = {z: 1};\n"
420                "}");
421   verifyFormat("x = foo && {a: 123};");
422 
423   // Arrow functions in object literals.
424   verifyFormat("var x = {\n"
425                "  y: (a) => {\n"
426                "    return a;\n"
427                "  }\n"
428                "};");
429   verifyFormat("var x = {y: (a) => a};");
430 
431   // Methods in object literals.
432   verifyFormat("var x = {\n"
433                "  y(a: string): number {\n"
434                "    return a;\n"
435                "  }\n"
436                "};");
437   verifyFormat("var x = {\n"
438                "  y(a: string) {\n"
439                "    return a;\n"
440                "  }\n"
441                "};");
442 
443   // Computed keys.
444   verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
445   verifyFormat("var x = {\n"
446                "  [a]: 1,\n"
447                "  b: 2,\n"
448                "  [c]: 3,\n"
449                "};");
450 
451   // Object literals can leave out labels.
452   verifyFormat("f({a}, () => {\n"
453                "  g();  //\n"
454                "});");
455 
456   // Keys can be quoted.
457   verifyFormat("var x = {\n"
458                "  a: a,\n"
459                "  b: b,\n"
460                "  'c': c,\n"
461                "};");
462 
463   // Dict literals can skip the label names.
464   verifyFormat("var x = {\n"
465                "  aaa,\n"
466                "  aaa,\n"
467                "  aaa,\n"
468                "};");
469   verifyFormat("return {\n"
470                "  a,\n"
471                "  b: 'b',\n"
472                "  c,\n"
473                "};");
474 }
475 
476 TEST_F(FormatTestJS, MethodsInObjectLiterals) {
477   verifyFormat("var o = {\n"
478                "  value: 'test',\n"
479                "  get value() {  // getter\n"
480                "    return this.value;\n"
481                "  }\n"
482                "};");
483   verifyFormat("var o = {\n"
484                "  value: 'test',\n"
485                "  set value(val) {  // setter\n"
486                "    this.value = val;\n"
487                "  }\n"
488                "};");
489   verifyFormat("var o = {\n"
490                "  value: 'test',\n"
491                "  someMethod(val) {  // method\n"
492                "    doSomething(this.value + val);\n"
493                "  }\n"
494                "};");
495   verifyFormat("var o = {\n"
496                "  someMethod(val) {  // method\n"
497                "    doSomething(this.value + val);\n"
498                "  },\n"
499                "  someOtherMethod(val) {  // method\n"
500                "    doSomething(this.value + val);\n"
501                "  }\n"
502                "};");
503 }
504 
505 TEST_F(FormatTestJS, GettersSettersVisibilityKeywords) {
506   // Don't break after "protected"
507   verifyFormat("class X {\n"
508                "  protected get getter():\n"
509                "      number {\n"
510                "    return 1;\n"
511                "  }\n"
512                "}",
513                getGoogleJSStyleWithColumns(12));
514   // Don't break after "get"
515   verifyFormat("class X {\n"
516                "  protected get someReallyLongGetterName():\n"
517                "      number {\n"
518                "    return 1;\n"
519                "  }\n"
520                "}",
521                getGoogleJSStyleWithColumns(40));
522 }
523 
524 TEST_F(FormatTestJS, SpacesInContainerLiterals) {
525   verifyFormat("var arr = [1, 2, 3];");
526   verifyFormat("f({a: 1, b: 2, c: 3});");
527 
528   verifyFormat("var object_literal_with_long_name = {\n"
529                "  a: 'aaaaaaaaaaaaaaaaaa',\n"
530                "  b: 'bbbbbbbbbbbbbbbbbb'\n"
531                "};");
532 
533   verifyFormat("f({a: 1, b: 2, c: 3});",
534                getChromiumStyle(FormatStyle::LK_JavaScript));
535   verifyFormat("f({'a': [{}]});");
536 }
537 
538 TEST_F(FormatTestJS, SingleQuotedStrings) {
539   verifyFormat("this.function('', true);");
540 }
541 
542 TEST_F(FormatTestJS, GoogScopes) {
543   verifyFormat("goog.scope(function() {\n"
544                "var x = a.b;\n"
545                "var y = c.d;\n"
546                "});  // goog.scope");
547   verifyFormat("goog.scope(function() {\n"
548                "// test\n"
549                "var x = 0;\n"
550                "// test\n"
551                "});");
552 }
553 
554 TEST_F(FormatTestJS, IIFEs) {
555   // Internal calling parens; no semi.
556   verifyFormat("(function() {\n"
557                "var a = 1;\n"
558                "}())");
559   // External calling parens; no semi.
560   verifyFormat("(function() {\n"
561                "var b = 2;\n"
562                "})()");
563   // Internal calling parens; with semi.
564   verifyFormat("(function() {\n"
565                "var c = 3;\n"
566                "}());");
567   // External calling parens; with semi.
568   verifyFormat("(function() {\n"
569                "var d = 4;\n"
570                "})();");
571 }
572 
573 TEST_F(FormatTestJS, GoogModules) {
574   verifyFormat("goog.module('this.is.really.absurdly.long');",
575                getGoogleJSStyleWithColumns(40));
576   verifyFormat("goog.require('this.is.really.absurdly.long');",
577                getGoogleJSStyleWithColumns(40));
578   verifyFormat("goog.provide('this.is.really.absurdly.long');",
579                getGoogleJSStyleWithColumns(40));
580   verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
581                getGoogleJSStyleWithColumns(40));
582   verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
583                getGoogleJSStyleWithColumns(40));
584 
585   // These should be wrapped normally.
586   verifyFormat(
587       "var MyLongClassName =\n"
588       "    goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
589   verifyFormat("function a() {\n"
590                "  goog.setTestOnly();\n"
591                "}\n",
592                "function a() {\n"
593                "goog.setTestOnly();\n"
594                "}\n");
595 }
596 
597 TEST_F(FormatTestJS, FormatsNamespaces) {
598   verifyFormat("namespace Foo {\n"
599                "  export let x = 1;\n"
600                "}\n");
601   verifyFormat("declare namespace Foo {\n"
602                "  export let x: number;\n"
603                "}\n");
604 }
605 
606 TEST_F(FormatTestJS, NamespacesMayNotWrap) {
607   verifyFormat("declare namespace foobarbaz {\n"
608                "}\n", getGoogleJSStyleWithColumns(18));
609   verifyFormat("declare module foobarbaz {\n"
610                "}\n", getGoogleJSStyleWithColumns(15));
611   verifyFormat("namespace foobarbaz {\n"
612                "}\n", getGoogleJSStyleWithColumns(10));
613   verifyFormat("module foobarbaz {\n"
614                "}\n", getGoogleJSStyleWithColumns(7));
615 }
616 
617 TEST_F(FormatTestJS, AmbientDeclarations) {
618   FormatStyle NineCols = getGoogleJSStyleWithColumns(9);
619   verifyFormat(
620       "declare class\n"
621       "    X {}",
622       NineCols);
623   verifyFormat(
624       "declare function\n"
625       "x();",  // TODO(martinprobst): should ideally be indented.
626       NineCols);
627   verifyFormat("declare function foo();\n"
628                "let x = 1;\n");
629   verifyFormat("declare function foo(): string;\n"
630                "let x = 1;\n");
631   verifyFormat("declare function foo(): {x: number};\n"
632                "let x = 1;\n");
633   verifyFormat("declare class X {}\n"
634                "let x = 1;\n");
635   verifyFormat("declare interface Y {}\n"
636                "let x = 1;\n");
637   verifyFormat(
638       "declare enum X {\n"
639       "}",
640       NineCols);
641   verifyFormat(
642       "declare let\n"
643       "    x: number;",
644       NineCols);
645 }
646 
647 TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
648   verifyFormat("function outer1(a, b) {\n"
649                "  function inner1(a, b) {\n"
650                "    return a;\n"
651                "  }\n"
652                "  inner1(a, b);\n"
653                "}\n"
654                "function outer2(a, b) {\n"
655                "  function inner2(a, b) {\n"
656                "    return a;\n"
657                "  }\n"
658                "  inner2(a, b);\n"
659                "}");
660   verifyFormat("function f() {}");
661   verifyFormat("function aFunction() {}\n"
662                "(function f() {\n"
663                "  var x = 1;\n"
664                "}());\n");
665   verifyFormat("function aFunction() {}\n"
666                "{\n"
667                "  let x = 1;\n"
668                "  console.log(x);\n"
669                "}\n");
670 }
671 
672 TEST_F(FormatTestJS, GeneratorFunctions) {
673   verifyFormat("function* f() {\n"
674                "  let x = 1;\n"
675                "  yield x;\n"
676                "  yield* something();\n"
677                "  yield [1, 2];\n"
678                "  yield {a: 1};\n"
679                "}");
680   verifyFormat("function*\n"
681                "    f() {\n"
682                "}",
683                getGoogleJSStyleWithColumns(8));
684   verifyFormat("export function* f() {\n"
685                "  yield 1;\n"
686                "}\n");
687   verifyFormat("class X {\n"
688                "  * generatorMethod() {\n"
689                "    yield x;\n"
690                "  }\n"
691                "}");
692   verifyFormat("var x = {\n"
693                "  a: function*() {\n"
694                "    //\n"
695                "  }\n"
696                "}\n");
697 }
698 
699 TEST_F(FormatTestJS, AsyncFunctions) {
700   verifyFormat("async function f() {\n"
701                "  let x = 1;\n"
702                "  return fetch(x);\n"
703                "}");
704   verifyFormat("async function f() {\n"
705                "  return 1;\n"
706                "}\n"
707                "\n"
708                "function a() {\n"
709                "  return 1;\n"
710                "}\n",
711                "  async   function f() {\n"
712                "   return 1;\n"
713                "}\n"
714                "\n"
715                "   function a() {\n"
716                "  return   1;\n"
717                "}  \n");
718   verifyFormat("async function* f() {\n"
719                "  yield fetch(x);\n"
720                "}");
721   verifyFormat("export async function f() {\n"
722                "  return fetch(x);\n"
723                "}");
724   verifyFormat("let x = async () => f();");
725   verifyFormat("let x = async function() {\n"
726                "  f();\n"
727                "};");
728   verifyFormat("let x = async();");
729   verifyFormat("class X {\n"
730                "  async asyncMethod() {\n"
731                "    return fetch(1);\n"
732                "  }\n"
733                "}");
734   verifyFormat("function initialize() {\n"
735                "  // Comment.\n"
736                "  return async.then();\n"
737                "}\n");
738   verifyFormat("for await (const x of y) {\n"
739                "  console.log(x);\n"
740                "}\n");
741   verifyFormat("function asyncLoop() {\n"
742                "  for await (const x of y) {\n"
743                "    console.log(x);\n"
744                "  }\n"
745                "}\n");
746 }
747 
748 TEST_F(FormatTestJS, FunctionParametersTrailingComma) {
749   verifyFormat("function trailingComma(\n"
750                "    p1,\n"
751                "    p2,\n"
752                "    p3,\n"
753                ") {\n"
754                "  a;  //\n"
755                "}\n",
756                "function trailingComma(p1, p2, p3,) {\n"
757                "  a;  //\n"
758                "}\n");
759   verifyFormat("trailingComma(\n"
760                "    p1,\n"
761                "    p2,\n"
762                "    p3,\n"
763                ");\n",
764                "trailingComma(p1, p2, p3,);\n");
765   verifyFormat("trailingComma(\n"
766                "    p1  // hello\n"
767                ");\n",
768                "trailingComma(p1 // hello\n"
769                ");\n");
770 }
771 
772 TEST_F(FormatTestJS, ArrayLiterals) {
773   verifyFormat("var aaaaa: List<SomeThing> =\n"
774                "    [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
775   verifyFormat("return [\n"
776                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
777                "  ccccccccccccccccccccccccccc\n"
778                "];");
779   verifyFormat("return [\n"
780                "  aaaa().bbbbbbbb('A'),\n"
781                "  aaaa().bbbbbbbb('B'),\n"
782                "  aaaa().bbbbbbbb('C'),\n"
783                "];");
784   verifyFormat("var someVariable = SomeFunction([\n"
785                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
786                "  ccccccccccccccccccccccccccc\n"
787                "]);");
788   verifyFormat("var someVariable = SomeFunction([\n"
789                "  [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
790                "]);",
791                getGoogleJSStyleWithColumns(51));
792   verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
793                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
794                "  ccccccccccccccccccccccccccc\n"
795                "]);");
796   verifyFormat("var someVariable = SomeFunction(\n"
797                "    aaaa,\n"
798                "    [\n"
799                "      aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
800                "      cccccccccccccccccccccccccc\n"
801                "    ],\n"
802                "    aaaa);");
803   verifyFormat("var aaaa = aaaaa ||  // wrap\n"
804                "    [];");
805 
806   verifyFormat("someFunction([], {a: a});");
807 
808   verifyFormat("var string = [\n"
809                "  'aaaaaa',\n"
810                "  'bbbbbb',\n"
811                "].join('+');");
812 }
813 
814 TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
815   verifyFormat("var array = [\n"
816                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
817                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
818                "];");
819   verifyFormat("var array = someFunction([\n"
820                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
821                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
822                "]);");
823 }
824 
825 TEST_F(FormatTestJS, FunctionLiterals) {
826   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
827   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
828   verifyFormat("doFoo(function() {});");
829   verifyFormat("doFoo(function() { return 1; });", Style);
830   verifyFormat("var func = function() {\n"
831                "  return 1;\n"
832                "};");
833   verifyFormat("var func =  //\n"
834                "    function() {\n"
835                "  return 1;\n"
836                "};");
837   verifyFormat("return {\n"
838                "  body: {\n"
839                "    setAttribute: function(key, val) { this[key] = val; },\n"
840                "    getAttribute: function(key) { return this[key]; },\n"
841                "    style: {direction: ''}\n"
842                "  }\n"
843                "};",
844                Style);
845   verifyFormat("abc = xyz ? function() {\n"
846                "  return 1;\n"
847                "} : function() {\n"
848                "  return -1;\n"
849                "};");
850 
851   verifyFormat("var closure = goog.bind(\n"
852                "    function() {  // comment\n"
853                "      foo();\n"
854                "      bar();\n"
855                "    },\n"
856                "    this, arg1IsReallyLongAndNeedsLineBreaks,\n"
857                "    arg3IsReallyLongAndNeedsLineBreaks);");
858   verifyFormat("var closure = goog.bind(function() {  // comment\n"
859                "  foo();\n"
860                "  bar();\n"
861                "}, this);");
862   verifyFormat("return {\n"
863                "  a: 'E',\n"
864                "  b: function() {\n"
865                "    return function() {\n"
866                "      f();  //\n"
867                "    };\n"
868                "  }\n"
869                "};");
870   verifyFormat("{\n"
871                "  var someVariable = function(x) {\n"
872                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
873                "  };\n"
874                "}");
875   verifyFormat("someLooooooooongFunction(\n"
876                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
877                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
878                "    function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
879                "      // code\n"
880                "    });");
881 
882   verifyFormat("return {\n"
883                "  a: function SomeFunction() {\n"
884                "    // ...\n"
885                "    return 1;\n"
886                "  }\n"
887                "};");
888   verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
889                "    .then(goog.bind(function(aaaaaaaaaaa) {\n"
890                "      someFunction();\n"
891                "      someFunction();\n"
892                "    }, this), aaaaaaaaaaaaaaaaa);");
893 
894   verifyFormat("someFunction(goog.bind(function() {\n"
895                "  doSomething();\n"
896                "  doSomething();\n"
897                "}, this), goog.bind(function() {\n"
898                "  doSomething();\n"
899                "  doSomething();\n"
900                "}, this));");
901 
902   verifyFormat("SomeFunction(function() {\n"
903                "  foo();\n"
904                "  bar();\n"
905                "}.bind(this));");
906 
907   verifyFormat("SomeFunction((function() {\n"
908                "               foo();\n"
909                "               bar();\n"
910                "             }).bind(this));");
911 
912   // FIXME: This is bad, we should be wrapping before "function() {".
913   verifyFormat("someFunction(function() {\n"
914                "  doSomething();  // break\n"
915                "})\n"
916                "    .doSomethingElse(\n"
917                "        // break\n"
918                "    );");
919 
920   Style.ColumnLimit = 33;
921   verifyFormat("f({a: function() { return 1; }});", Style);
922   Style.ColumnLimit = 32;
923   verifyFormat("f({\n"
924                "  a: function() { return 1; }\n"
925                "});",
926                Style);
927 
928 }
929 
930 TEST_F(FormatTestJS, DontWrapEmptyLiterals) {
931   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
932                "    .and.returnValue(Observable.of([]));");
933   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
934                "    .and.returnValue(Observable.of({}));");
935   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
936                "    .and.returnValue(Observable.of(()));");
937 }
938 
939 TEST_F(FormatTestJS, InliningFunctionLiterals) {
940   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
941   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
942   verifyFormat("var func = function() {\n"
943                "  return 1;\n"
944                "};",
945                Style);
946   verifyFormat("var func = doSomething(function() { return 1; });", Style);
947   verifyFormat("var outer = function() {\n"
948                "  var inner = function() { return 1; }\n"
949                "};",
950                Style);
951   verifyFormat("function outer1(a, b) {\n"
952                "  function inner1(a, b) { return a; }\n"
953                "}",
954                Style);
955 
956   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
957   verifyFormat("var func = function() { return 1; };", Style);
958   verifyFormat("var func = doSomething(function() { return 1; });", Style);
959   verifyFormat(
960       "var outer = function() { var inner = function() { return 1; } };",
961       Style);
962   verifyFormat("function outer1(a, b) {\n"
963                "  function inner1(a, b) { return a; }\n"
964                "}",
965                Style);
966 
967   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
968   verifyFormat("var func = function() {\n"
969                "  return 1;\n"
970                "};",
971                Style);
972   verifyFormat("var func = doSomething(function() {\n"
973                "  return 1;\n"
974                "});",
975                Style);
976   verifyFormat("var outer = function() {\n"
977                "  var inner = function() {\n"
978                "    return 1;\n"
979                "  }\n"
980                "};",
981                Style);
982   verifyFormat("function outer1(a, b) {\n"
983                "  function inner1(a, b) {\n"
984                "    return a;\n"
985                "  }\n"
986                "}",
987                Style);
988 
989   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
990   verifyFormat("var func = function() {\n"
991                "  return 1;\n"
992                "};",
993                Style);
994 }
995 
996 TEST_F(FormatTestJS, MultipleFunctionLiterals) {
997   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
998   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
999   verifyFormat("promise.then(\n"
1000                "    function success() {\n"
1001                "      doFoo();\n"
1002                "      doBar();\n"
1003                "    },\n"
1004                "    function error() {\n"
1005                "      doFoo();\n"
1006                "      doBaz();\n"
1007                "    },\n"
1008                "    []);\n");
1009   verifyFormat("promise.then(\n"
1010                "    function success() {\n"
1011                "      doFoo();\n"
1012                "      doBar();\n"
1013                "    },\n"
1014                "    [],\n"
1015                "    function error() {\n"
1016                "      doFoo();\n"
1017                "      doBaz();\n"
1018                "    });\n");
1019   verifyFormat("promise.then(\n"
1020                "    [],\n"
1021                "    function success() {\n"
1022                "      doFoo();\n"
1023                "      doBar();\n"
1024                "    },\n"
1025                "    function error() {\n"
1026                "      doFoo();\n"
1027                "      doBaz();\n"
1028                "    });\n");
1029 
1030   verifyFormat("getSomeLongPromise()\n"
1031                "    .then(function(value) { body(); })\n"
1032                "    .thenCatch(function(error) {\n"
1033                "      body();\n"
1034                "      body();\n"
1035                "    });",
1036                Style);
1037   verifyFormat("getSomeLongPromise()\n"
1038                "    .then(function(value) {\n"
1039                "      body();\n"
1040                "      body();\n"
1041                "    })\n"
1042                "    .thenCatch(function(error) {\n"
1043                "      body();\n"
1044                "      body();\n"
1045                "    });");
1046 
1047   verifyFormat("getSomeLongPromise()\n"
1048                "    .then(function(value) { body(); })\n"
1049                "    .thenCatch(function(error) { body(); });",
1050                Style);
1051 
1052   verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
1053                "    .aaaaaaa(function() {\n"
1054                "      //\n"
1055                "    })\n"
1056                "    .bbbbbb();");
1057 }
1058 
1059 TEST_F(FormatTestJS, ArrowFunctions) {
1060   verifyFormat("var x = (a) => {\n"
1061                "  return a;\n"
1062                "};");
1063   verifyFormat("var x = (a) => {\n"
1064                "  function y() {\n"
1065                "    return 42;\n"
1066                "  }\n"
1067                "  return a;\n"
1068                "};");
1069   verifyFormat("var x = (a: type): {some: type} => {\n"
1070                "  return a;\n"
1071                "};");
1072   verifyFormat("var x = (a) => a;");
1073   verifyFormat("return () => [];");
1074   verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
1075                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
1076                "      (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1077                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
1078                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1079                "};");
1080   verifyFormat("var a = a.aaaaaaa(\n"
1081                "    (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
1082                "        aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
1083   verifyFormat("var a = a.aaaaaaa(\n"
1084                "    (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
1085                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
1086                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
1087 
1088   // FIXME: This is bad, we should be wrapping before "() => {".
1089   verifyFormat("someFunction(() => {\n"
1090                "  doSomething();  // break\n"
1091                "})\n"
1092                "    .doSomethingElse(\n"
1093                "        // break\n"
1094                "    );");
1095   verifyFormat("const f = (x: string|null): string|null => {\n"
1096                "  return x;\n"
1097                "}\n");
1098 }
1099 
1100 TEST_F(FormatTestJS, ReturnStatements) {
1101   verifyFormat("function() {\n"
1102                "  return [hello, world];\n"
1103                "}");
1104 }
1105 
1106 TEST_F(FormatTestJS, ForLoops) {
1107   verifyFormat("for (var i in [2, 3]) {\n"
1108                "}");
1109   verifyFormat("for (var i of [2, 3]) {\n"
1110                "}");
1111   verifyFormat("for (let {a, b} of x) {\n"
1112                "}");
1113   verifyFormat("for (let {a, b} in x) {\n"
1114                "}");
1115 }
1116 
1117 TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
1118   // The following statements must not wrap, as otherwise the program meaning
1119   // would change due to automatic semicolon insertion.
1120   // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
1121   verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
1122   verifyFormat("return /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
1123   verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
1124   verifyFormat("continue /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
1125   verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
1126   verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
1127   verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
1128   verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
1129   verifyFormat("return [\n"
1130                "  aaa\n"
1131                "];",
1132                getGoogleJSStyleWithColumns(12));
1133   verifyFormat("class X {\n"
1134                "  readonly ratherLongField =\n"
1135                "      1;\n"
1136                "}",
1137                "class X {\n"
1138                "  readonly ratherLongField = 1;\n"
1139                "}",
1140                getGoogleJSStyleWithColumns(20));
1141   verifyFormat("const x = (5 + 9)\n"
1142                "const y = 3\n",
1143                "const x = (   5 +    9)\n"
1144                "const y = 3\n");
1145 }
1146 
1147 TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
1148   verifyFormat("a\n"
1149                "b;",
1150                " a \n"
1151                " b ;");
1152   verifyFormat("a()\n"
1153                "b;",
1154                " a ()\n"
1155                " b ;");
1156   verifyFormat("a[b]\n"
1157                "c;",
1158                "a [b]\n"
1159                "c ;");
1160   verifyFormat("1\n"
1161                "a;",
1162                "1 \n"
1163                "a ;");
1164   verifyFormat("a\n"
1165                "1;",
1166                "a \n"
1167                "1 ;");
1168   verifyFormat("a\n"
1169                "'x';",
1170                "a \n"
1171                " 'x';");
1172   verifyFormat("a++\n"
1173                "b;",
1174                "a ++\n"
1175                "b ;");
1176   verifyFormat("a\n"
1177                "!b && c;",
1178                "a \n"
1179                " ! b && c;");
1180   verifyFormat("a\n"
1181                "if (1) f();",
1182                " a\n"
1183                " if (1) f();");
1184   verifyFormat("a\n"
1185                "class X {}",
1186                " a\n"
1187                " class X {}");
1188   verifyFormat("var a", "var\n"
1189                         "a");
1190   verifyFormat("x instanceof String", "x\n"
1191                                       "instanceof\n"
1192                                       "String");
1193   verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
1194                                           "  bar) {}");
1195   verifyFormat("a = true\n"
1196                "return 1",
1197                "a = true\n"
1198                "  return   1");
1199   verifyFormat("a = 's'\n"
1200                "return 1",
1201                "a = 's'\n"
1202                "  return   1");
1203   verifyFormat("a = null\n"
1204                "return 1",
1205                "a = null\n"
1206                "  return   1");
1207   // Below "class Y {}" should ideally be on its own line.
1208   verifyFormat(
1209       "x = {\n"
1210       "  a: 1\n"
1211       "} class Y {}",
1212       "  x  =  {a  : 1}\n"
1213       "   class  Y {  }");
1214   verifyFormat(
1215       "if (x) {\n"
1216       "}\n"
1217       "return 1",
1218       "if (x) {}\n"
1219       " return   1");
1220   verifyFormat(
1221       "if (x) {\n"
1222       "}\n"
1223       "class X {}",
1224       "if (x) {}\n"
1225       " class X {}");
1226 }
1227 
1228 TEST_F(FormatTestJS, ImportExportASI) {
1229   verifyFormat(
1230       "import {x} from 'y'\n"
1231       "export function z() {}",
1232       "import   {x} from 'y'\n"
1233       "  export function z() {}");
1234   // Below "class Y {}" should ideally be on its own line.
1235   verifyFormat(
1236       "export {x} class Y {}",
1237       "  export {x}\n"
1238       "  class  Y {\n}");
1239   verifyFormat(
1240       "if (x) {\n"
1241       "}\n"
1242       "export class Y {}",
1243       "if ( x ) { }\n"
1244       " export class Y {}");
1245 }
1246 
1247 TEST_F(FormatTestJS, ClosureStyleCasts) {
1248   verifyFormat("var x = /** @type {foo} */ (bar);");
1249 }
1250 
1251 TEST_F(FormatTestJS, TryCatch) {
1252   verifyFormat("try {\n"
1253                "  f();\n"
1254                "} catch (e) {\n"
1255                "  g();\n"
1256                "} finally {\n"
1257                "  h();\n"
1258                "}");
1259 
1260   // But, of course, "catch" is a perfectly fine function name in JavaScript.
1261   verifyFormat("someObject.catch();");
1262   verifyFormat("someObject.new();");
1263 }
1264 
1265 TEST_F(FormatTestJS, StringLiteralConcatenation) {
1266   verifyFormat("var literal = 'hello ' +\n"
1267                "    'world';");
1268 }
1269 
1270 TEST_F(FormatTestJS, RegexLiteralClassification) {
1271   // Regex literals.
1272   verifyFormat("var regex = /abc/;");
1273   verifyFormat("f(/abc/);");
1274   verifyFormat("f(abc, /abc/);");
1275   verifyFormat("some_map[/abc/];");
1276   verifyFormat("var x = a ? /abc/ : /abc/;");
1277   verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
1278   verifyFormat("var x = !/abc/.test(y);");
1279   verifyFormat("var x = foo()! / 10;");
1280   verifyFormat("var x = a && /abc/.test(y);");
1281   verifyFormat("var x = a || /abc/.test(y);");
1282   verifyFormat("var x = a + /abc/.search(y);");
1283   verifyFormat("/abc/.search(y);");
1284   verifyFormat("var regexs = {/abc/, /abc/};");
1285   verifyFormat("return /abc/;");
1286 
1287   // Not regex literals.
1288   verifyFormat("var a = a / 2 + b / 3;");
1289   verifyFormat("var a = a++ / 2;");
1290   // Prefix unary can operate on regex literals, not that it makes sense.
1291   verifyFormat("var a = ++/a/;");
1292 
1293   // This is a known issue, regular expressions are incorrectly detected if
1294   // directly following a closing parenthesis.
1295   verifyFormat("if (foo) / bar /.exec(baz);");
1296 }
1297 
1298 TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
1299   verifyFormat("var regex = /=/;");
1300   verifyFormat("var regex = /a*/;");
1301   verifyFormat("var regex = /a+/;");
1302   verifyFormat("var regex = /a?/;");
1303   verifyFormat("var regex = /.a./;");
1304   verifyFormat("var regex = /a\\*/;");
1305   verifyFormat("var regex = /^a$/;");
1306   verifyFormat("var regex = /\\/a/;");
1307   verifyFormat("var regex = /(?:x)/;");
1308   verifyFormat("var regex = /x(?=y)/;");
1309   verifyFormat("var regex = /x(?!y)/;");
1310   verifyFormat("var regex = /x|y/;");
1311   verifyFormat("var regex = /a{2}/;");
1312   verifyFormat("var regex = /a{1,3}/;");
1313 
1314   verifyFormat("var regex = /[abc]/;");
1315   verifyFormat("var regex = /[^abc]/;");
1316   verifyFormat("var regex = /[\\b]/;");
1317   verifyFormat("var regex = /[/]/;");
1318   verifyFormat("var regex = /[\\/]/;");
1319   verifyFormat("var regex = /\\[/;");
1320   verifyFormat("var regex = /\\\\[/]/;");
1321   verifyFormat("var regex = /}[\"]/;");
1322   verifyFormat("var regex = /}[/\"]/;");
1323   verifyFormat("var regex = /}[\"/]/;");
1324 
1325   verifyFormat("var regex = /\\b/;");
1326   verifyFormat("var regex = /\\B/;");
1327   verifyFormat("var regex = /\\d/;");
1328   verifyFormat("var regex = /\\D/;");
1329   verifyFormat("var regex = /\\f/;");
1330   verifyFormat("var regex = /\\n/;");
1331   verifyFormat("var regex = /\\r/;");
1332   verifyFormat("var regex = /\\s/;");
1333   verifyFormat("var regex = /\\S/;");
1334   verifyFormat("var regex = /\\t/;");
1335   verifyFormat("var regex = /\\v/;");
1336   verifyFormat("var regex = /\\w/;");
1337   verifyFormat("var regex = /\\W/;");
1338   verifyFormat("var regex = /a(a)\\1/;");
1339   verifyFormat("var regex = /\\0/;");
1340   verifyFormat("var regex = /\\\\/g;");
1341   verifyFormat("var regex = /\\a\\\\/g;");
1342   verifyFormat("var regex = /\a\\//g;");
1343   verifyFormat("var regex = /a\\//;\n"
1344                "var x = 0;");
1345   verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
1346   verifyFormat("var regex = /'/g;  //'", "var regex = /'/g ; //'");
1347   verifyFormat("var regex = /\\/*/;\n"
1348                "var x = 0;",
1349                "var regex = /\\/*/;\n"
1350                "var x=0;");
1351   verifyFormat("var x = /a\\//;", "var x = /a\\//  \n;");
1352   verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
1353   verifyFormat("var regex =\n"
1354                "    /\"/;",
1355                getGoogleJSStyleWithColumns(15));
1356   verifyFormat("var regex =  //\n"
1357                "    /a/;");
1358   verifyFormat("var regexs = [\n"
1359                "  /d/,   //\n"
1360                "  /aa/,  //\n"
1361                "];");
1362 }
1363 
1364 TEST_F(FormatTestJS, RegexLiteralModifiers) {
1365   verifyFormat("var regex = /abc/g;");
1366   verifyFormat("var regex = /abc/i;");
1367   verifyFormat("var regex = /abc/m;");
1368   verifyFormat("var regex = /abc/y;");
1369 }
1370 
1371 TEST_F(FormatTestJS, RegexLiteralLength) {
1372   verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1373                getGoogleJSStyleWithColumns(60));
1374   verifyFormat("var regex =\n"
1375                "    /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1376                getGoogleJSStyleWithColumns(60));
1377   verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1378                getGoogleJSStyleWithColumns(50));
1379 }
1380 
1381 TEST_F(FormatTestJS, RegexLiteralExamples) {
1382   verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
1383 }
1384 
1385 TEST_F(FormatTestJS, IgnoresMpegTS) {
1386   std::string MpegTS(200, ' ');
1387   MpegTS.replace(0, strlen("nearlyLooks  +   like +   ts + code;  "),
1388                  "nearlyLooks  +   like +   ts + code;  ");
1389   MpegTS[0] = 0x47;
1390   MpegTS[188] = 0x47;
1391   verifyFormat(MpegTS, MpegTS);
1392 }
1393 
1394 TEST_F(FormatTestJS, TypeAnnotations) {
1395   verifyFormat("var x: string;");
1396   verifyFormat("var x: {a: string; b: number;} = {};");
1397   verifyFormat("function x(): string {\n  return 'x';\n}");
1398   verifyFormat("function x(): {x: string} {\n  return {x: 'x'};\n}");
1399   verifyFormat("function x(y: string): string {\n  return 'x';\n}");
1400   verifyFormat("for (var y: string in x) {\n  x();\n}");
1401   verifyFormat("for (var y: string of x) {\n  x();\n}");
1402   verifyFormat("function x(y: {a?: number;} = {}): number {\n"
1403                "  return 12;\n"
1404                "}");
1405   verifyFormat("((a: string, b: number): string => a + b);");
1406   verifyFormat("var x: (y: number) => string;");
1407   verifyFormat("var x: P<string, (a: number) => string>;");
1408   verifyFormat("var x = {\n"
1409                "  y: function(): z {\n"
1410                "    return 1;\n"
1411                "  }\n"
1412                "};");
1413   verifyFormat("var x = {\n"
1414                "  y: function(): {a: number} {\n"
1415                "    return 1;\n"
1416                "  }\n"
1417                "};");
1418   verifyFormat("function someFunc(args: string[]):\n"
1419                "    {longReturnValue: string[]} {}",
1420                getGoogleJSStyleWithColumns(60));
1421   verifyFormat(
1422       "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n"
1423       "                    .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
1424 }
1425 
1426 TEST_F(FormatTestJS, UnionIntersectionTypes) {
1427   verifyFormat("let x: A|B = A | B;");
1428   verifyFormat("let x: A&B|C = A & B;");
1429   verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
1430   verifyFormat("function(x: A|B): C&D {}");
1431   verifyFormat("function(x: A|B = A | B): C&D {}");
1432   verifyFormat("function x(path: number|string) {}");
1433   verifyFormat("function x(): string|number {}");
1434   verifyFormat("type Foo = Bar|Baz;");
1435   verifyFormat("type Foo = Bar<X>|Baz;");
1436   verifyFormat("type Foo = (Bar<X>|Baz);");
1437   verifyFormat("let x: Bar|Baz;");
1438   verifyFormat("let x: Bar<X>|Baz;");
1439   verifyFormat("let x: (Foo|Bar)[];");
1440   verifyFormat("type X = {\n"
1441                "  a: Foo|Bar;\n"
1442                "};");
1443   verifyFormat("export type X = {\n"
1444                "  a: Foo|Bar;\n"
1445                "};");
1446 }
1447 
1448 TEST_F(FormatTestJS, UnionIntersectionTypesInObjectType) {
1449   verifyFormat("let x: {x: number|null} = {x: number | null};");
1450   verifyFormat("let nested: {x: {y: number|null}};");
1451   verifyFormat("let mixed: {x: [number|null, {w: number}]};");
1452   verifyFormat("class X {\n"
1453                "  contructor(x: {\n"
1454                "    a: a|null,\n"
1455                "    b: b|null,\n"
1456                "  }) {}\n"
1457                "}");
1458 }
1459 
1460 TEST_F(FormatTestJS, ClassDeclarations) {
1461   verifyFormat("class C {\n  x: string = 12;\n}");
1462   verifyFormat("class C {\n  x(): string => 12;\n}");
1463   verifyFormat("class C {\n  ['x' + 2]: string = 12;\n}");
1464   verifyFormat("class C {\n"
1465                "  foo() {}\n"
1466                "  [bar]() {}\n"
1467                "}\n");
1468   verifyFormat("class C {\n  private x: string = 12;\n}");
1469   verifyFormat("class C {\n  private static x: string = 12;\n}");
1470   verifyFormat("class C {\n  static x(): string {\n    return 'asd';\n  }\n}");
1471   verifyFormat("class C extends P implements I {}");
1472   verifyFormat("class C extends p.P implements i.I {}");
1473   verifyFormat(
1474       "x(class {\n"
1475       "  a(): A {}\n"
1476       "});");
1477   verifyFormat("class Test {\n"
1478                "  aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
1479                "      aaaaaaaaaaaaaaaaaaaaaa {}\n"
1480                "}");
1481   verifyFormat("foo = class Name {\n"
1482                "  constructor() {}\n"
1483                "};");
1484   verifyFormat("foo = class {\n"
1485                "  constructor() {}\n"
1486                "};");
1487   verifyFormat("class C {\n"
1488                "  x: {y: Z;} = {};\n"
1489                "  private y: {y: Z;} = {};\n"
1490                "}");
1491 
1492   // ':' is not a type declaration here.
1493   verifyFormat("class X {\n"
1494                "  subs = {\n"
1495                "    'b': {\n"
1496                "      'c': 1,\n"
1497                "    },\n"
1498                "  };\n"
1499                "}");
1500   verifyFormat("@Component({\n"
1501                "  moduleId: module.id,\n"
1502                "})\n"
1503                "class SessionListComponent implements OnDestroy, OnInit {\n"
1504                "}");
1505 }
1506 
1507 TEST_F(FormatTestJS, InterfaceDeclarations) {
1508   verifyFormat("interface I {\n"
1509                "  x: string;\n"
1510                "  enum: string[];\n"
1511                "  enum?: string[];\n"
1512                "}\n"
1513                "var y;");
1514   // Ensure that state is reset after parsing the interface.
1515   verifyFormat("interface a {}\n"
1516                "export function b() {}\n"
1517                "var x;");
1518 
1519   // Arrays of object type literals.
1520   verifyFormat("interface I {\n"
1521                "  o: {}[];\n"
1522                "}");
1523 }
1524 
1525 TEST_F(FormatTestJS, ObjectTypesInExtendsImplements) {
1526   verifyFormat("class C extends {} {}");
1527   verifyFormat("class C implements {bar: number} {}");
1528   // Somewhat odd, but probably closest to reasonable formatting?
1529   verifyFormat("class C implements {\n"
1530                "  bar: number,\n"
1531                "  baz: string,\n"
1532                "} {}");
1533   verifyFormat("class C<P extends {}> {}");
1534 }
1535 
1536 TEST_F(FormatTestJS, EnumDeclarations) {
1537   verifyFormat("enum Foo {\n"
1538                "  A = 1,\n"
1539                "  B\n"
1540                "}");
1541   verifyFormat("export /* somecomment*/ enum Foo {\n"
1542                "  A = 1,\n"
1543                "  B\n"
1544                "}");
1545   verifyFormat("enum Foo {\n"
1546                "  A = 1,  // comment\n"
1547                "  B\n"
1548                "}\n"
1549                "var x = 1;");
1550   verifyFormat("const enum Foo {\n"
1551                "  A = 1,\n"
1552                "  B\n"
1553                "}");
1554   verifyFormat("export const enum Foo {\n"
1555                "  A = 1,\n"
1556                "  B\n"
1557                "}");
1558 }
1559 
1560 TEST_F(FormatTestJS, MetadataAnnotations) {
1561   verifyFormat("@A\nclass C {\n}");
1562   verifyFormat("@A({arg: 'value'})\nclass C {\n}");
1563   verifyFormat("@A\n@B\nclass C {\n}");
1564   verifyFormat("class C {\n  @A x: string;\n}");
1565   verifyFormat("class C {\n"
1566                "  @A\n"
1567                "  private x(): string {\n"
1568                "    return 'y';\n"
1569                "  }\n"
1570                "}");
1571   verifyFormat("class C {\n"
1572                "  private x(@A x: string) {}\n"
1573                "}");
1574   verifyFormat("class X {}\n"
1575                "class Y {}");
1576   verifyFormat("class X {\n"
1577                "  @property() private isReply = false;\n"
1578                "}\n");
1579 }
1580 
1581 TEST_F(FormatTestJS, TypeAliases) {
1582   verifyFormat("type X = number;\n"
1583                "class C {}");
1584   verifyFormat("type X<Y> = Z<Y>;");
1585   verifyFormat("type X = {\n"
1586                "  y: number\n"
1587                "};\n"
1588                "class C {}");
1589   verifyFormat("export type X = {\n"
1590                "  a: string,\n"
1591                "  b?: string,\n"
1592                "};\n");
1593 }
1594 
1595 TEST_F(FormatTestJS, TypeInterfaceLineWrapping) {
1596   const FormatStyle &Style = getGoogleJSStyleWithColumns(20);
1597   verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n"
1598                "    string;\n",
1599                "type LongTypeIsReallyUnreasonablyLong = string;\n",
1600                Style);
1601   verifyFormat(
1602       "interface AbstractStrategyFactoryProvider {\n"
1603       "  a: number\n"
1604       "}\n",
1605       "interface AbstractStrategyFactoryProvider { a: number }\n",
1606       Style);
1607 }
1608 
1609 TEST_F(FormatTestJS, RemoveEmptyLinesInArrowFunctions) {
1610   verifyFormat("x = () => {\n"
1611                "  foo();\n"
1612                "};\n",
1613                "x = () => {\n"
1614                "\n"
1615                "  foo();\n"
1616                "\n"
1617                "};\n");
1618 }
1619 
1620 TEST_F(FormatTestJS, Modules) {
1621   verifyFormat("import SomeThing from 'some/module.js';");
1622   verifyFormat("import {X, Y} from 'some/module.js';");
1623   verifyFormat("import a, {X, Y} from 'some/module.js';");
1624   verifyFormat("import {X, Y,} from 'some/module.js';");
1625   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
1626   // Ensure Automatic Semicolon Insertion does not break on "as\n".
1627   verifyFormat("import {X as myX} from 'm';", "import {X as\n"
1628                                               " myX} from 'm';");
1629   verifyFormat("import * as lib from 'some/module.js';");
1630   verifyFormat("var x = {import: 1};\nx.import = 2;");
1631 
1632   verifyFormat("export function fn() {\n"
1633                "  return 'fn';\n"
1634                "}");
1635   verifyFormat("export function A() {}\n"
1636                "export default function B() {}\n"
1637                "export function C() {}");
1638   verifyFormat("export default () => {\n"
1639                "  let x = 1;\n"
1640                "  return x;\n"
1641                "}");
1642   verifyFormat("export const x = 12;");
1643   verifyFormat("export default class X {}");
1644   verifyFormat("export {X, Y} from 'some/module.js';");
1645   verifyFormat("export {X, Y,} from 'some/module.js';");
1646   verifyFormat("export {SomeVeryLongExport as X, "
1647                "SomeOtherVeryLongExport as Y} from 'some/module.js';");
1648   // export without 'from' is wrapped.
1649   verifyFormat("export let someRatherLongVariableName =\n"
1650                "    someSurprisinglyLongVariable + someOtherRatherLongVar;");
1651   // ... but not if from is just an identifier.
1652   verifyFormat("export {\n"
1653                "  from as from,\n"
1654                "  someSurprisinglyLongVariable as\n"
1655                "      from\n"
1656                "};",
1657                getGoogleJSStyleWithColumns(20));
1658   verifyFormat("export class C {\n"
1659                "  x: number;\n"
1660                "  y: string;\n"
1661                "}");
1662   verifyFormat("export class X { y: number; }");
1663   verifyFormat("export abstract class X { y: number; }");
1664   verifyFormat("export default class X { y: number }");
1665   verifyFormat("export default function() {\n  return 1;\n}");
1666   verifyFormat("export var x = 12;");
1667   verifyFormat("class C {}\n"
1668                "export function f() {}\n"
1669                "var v;");
1670   verifyFormat("export var x: number = 12;");
1671   verifyFormat("export const y = {\n"
1672                "  a: 1,\n"
1673                "  b: 2\n"
1674                "};");
1675   verifyFormat("export enum Foo {\n"
1676                "  BAR,\n"
1677                "  // adsdasd\n"
1678                "  BAZ\n"
1679                "}");
1680   verifyFormat("export default [\n"
1681                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1682                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
1683                "];");
1684   verifyFormat("export default [];");
1685   verifyFormat("export default () => {};");
1686   verifyFormat("export interface Foo { foo: number; }\n"
1687                "export class Bar {\n"
1688                "  blah(): string {\n"
1689                "    return this.blah;\n"
1690                "  };\n"
1691                "}");
1692 }
1693 
1694 TEST_F(FormatTestJS, ImportWrapping) {
1695   verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
1696                " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
1697                "} from 'some/module.js';");
1698   FormatStyle Style = getGoogleJSStyleWithColumns(80);
1699   Style.JavaScriptWrapImports = true;
1700   verifyFormat("import {\n"
1701                "  VeryLongImportsAreAnnoying,\n"
1702                "  VeryLongImportsAreAnnoying,\n"
1703                "  VeryLongImportsAreAnnoying,\n"
1704                "} from 'some/module.js';",
1705                Style);
1706   verifyFormat("import {\n"
1707                "  A,\n"
1708                "  A,\n"
1709                "} from 'some/module.js';",
1710                Style);
1711   verifyFormat("export {\n"
1712                "  A,\n"
1713                "  A,\n"
1714                "} from 'some/module.js';",
1715                Style);
1716   Style.ColumnLimit = 40;
1717   // Using this version of verifyFormat because test::messUp hides the issue.
1718   verifyFormat("import {\n"
1719                "  A,\n"
1720                "} from\n"
1721                "    'some/path/longer/than/column/limit/module.js';",
1722                " import  {  \n"
1723                "    A,  \n"
1724                "  }    from\n"
1725                "      'some/path/longer/than/column/limit/module.js'  ; ",
1726                Style);
1727 }
1728 
1729 TEST_F(FormatTestJS, TemplateStrings) {
1730   // Keeps any whitespace/indentation within the template string.
1731   verifyFormat("var x = `hello\n"
1732             "     ${name}\n"
1733             "  !`;",
1734             "var x    =    `hello\n"
1735                    "     ${  name    }\n"
1736                    "  !`;");
1737 
1738   verifyFormat("var x =\n"
1739                "    `hello ${world}` >= some();",
1740                getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
1741   verifyFormat("var x = `hello ${world}` >= some();",
1742                getGoogleJSStyleWithColumns(35)); // Barely fits.
1743   verifyFormat("var x = `hellö ${wörld}` >= söme();",
1744                getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8.
1745   verifyFormat("var x = `hello\n"
1746             "  ${world}` >=\n"
1747             "    some();",
1748             "var x =\n"
1749                    "    `hello\n"
1750                    "  ${world}` >= some();",
1751                    getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
1752   verifyFormat("var x = `hello\n"
1753             "  ${world}` >= some();",
1754             "var x =\n"
1755                    "    `hello\n"
1756                    "  ${world}` >= some();",
1757                    getGoogleJSStyleWithColumns(22)); // Barely fits.
1758 
1759   verifyFormat("var x =\n"
1760                "    `h`;",
1761                getGoogleJSStyleWithColumns(11));
1762   verifyFormat("var x =\n    `multi\n  line`;", "var x = `multi\n  line`;",
1763                getGoogleJSStyleWithColumns(13));
1764   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
1765                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
1766   // Repro for an obscure width-miscounting issue with template strings.
1767   verifyFormat(
1768       "someLongVariable =\n"
1769       "    "
1770       "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;",
1771       "someLongVariable = "
1772       "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;");
1773 
1774   // Make sure template strings get a proper ColumnWidth assigned, even if they
1775   // are first token in line.
1776   verifyFormat(
1777       "var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
1778       "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
1779 
1780   // Two template strings.
1781   verifyFormat("var x = `hello` == `hello`;");
1782 
1783   // Comments in template strings.
1784   verifyFormat("var x = `//a`;\n"
1785             "var y;",
1786             "var x =\n `//a`;\n"
1787                    "var y  ;");
1788   verifyFormat("var x = `/*a`;\n"
1789                "var y;",
1790                "var x =\n `/*a`;\n"
1791                "var y;");
1792   // Unterminated string literals in a template string.
1793   verifyFormat("var x = `'`;  // comment with matching quote '\n"
1794                "var y;");
1795   verifyFormat("var x = `\"`;  // comment with matching quote \"\n"
1796                "var y;");
1797   verifyFormat("it(`'aaaaaaaaaaaaaaa   `, aaaaaaaaa);",
1798                "it(`'aaaaaaaaaaaaaaa   `,   aaaaaaaaa) ;",
1799                getGoogleJSStyleWithColumns(40));
1800   // Backticks in a comment - not a template string.
1801   verifyFormat("var x = 1  // `/*a`;\n"
1802                "    ;",
1803                "var x =\n 1  // `/*a`;\n"
1804                "    ;");
1805   verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
1806   // Comment spans multiple template strings.
1807   verifyFormat("var x = `/*a`;\n"
1808                "var y = ` */ `;",
1809                "var x =\n `/*a`;\n"
1810                "var y =\n ` */ `;");
1811   // Escaped backtick.
1812   verifyFormat("var x = ` \\` a`;\n"
1813                "var y;",
1814                "var x = ` \\` a`;\n"
1815                "var y;");
1816   // Escaped dollar.
1817   verifyFormat("var x = ` \\${foo}`;\n");
1818 
1819   // The token stream can contain two string_literals in sequence, but that
1820   // doesn't mean that they are implicitly concatenated in JavaScript.
1821   verifyFormat("var f = `aaaa ${a ? 'a' : 'b'}`;");
1822 
1823   // Ensure that scopes are appropriately set around evaluated expressions in
1824   // template strings.
1825   verifyFormat("var f = `aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa\n"
1826                "         aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`;",
1827                "var f = `aaaaaaaaaaaaa:${aaaaaaa.  aaaaa} aaaaaaaa\n"
1828                "         aaaaaaaaaaaaa:${  aaaaaaa. aaaaa} aaaaaaaa`;");
1829   verifyFormat("var x = someFunction(`${})`)  //\n"
1830                "            .oooooooooooooooooon();");
1831   verifyFormat("var x = someFunction(`${aaaa}${\n"
1832                "    aaaaa(  //\n"
1833                "        aaaaa)})`);");
1834 }
1835 
1836 TEST_F(FormatTestJS, TemplateStringMultiLineExpression) {
1837   verifyFormat("var f = `aaaaaaaaaaaaaaaaaa: ${\n"
1838                "    aaaaa +  //\n"
1839                "    bbbb}`;",
1840                "var f = `aaaaaaaaaaaaaaaaaa: ${aaaaa +  //\n"
1841                "                               bbbb}`;");
1842   verifyFormat("var f = `\n"
1843                "  aaaaaaaaaaaaaaaaaa: ${\n"
1844                "    aaaaa +  //\n"
1845                "    bbbb}`;",
1846                "var f  =  `\n"
1847                "  aaaaaaaaaaaaaaaaaa: ${   aaaaa  +  //\n"
1848                "                        bbbb }`;");
1849   verifyFormat("var f = `\n"
1850                "  aaaaaaaaaaaaaaaaaa: ${\n"
1851                "    someFunction(\n"
1852                "        aaaaa +  //\n"
1853                "        bbbb)}`;",
1854                "var f  =  `\n"
1855                "  aaaaaaaaaaaaaaaaaa: ${someFunction (\n"
1856                "                            aaaaa  +   //\n"
1857                "                            bbbb)}`;");
1858 
1859   // It might be preferable to wrap before "someFunction".
1860   verifyFormat("var f = `\n"
1861                "  aaaaaaaaaaaaaaaaaa: ${someFunction({\n"
1862                "  aaaa: aaaaa,\n"
1863                "  bbbb: bbbbb,\n"
1864                "})}`;",
1865                "var f  =  `\n"
1866                "  aaaaaaaaaaaaaaaaaa: ${someFunction ({\n"
1867                "                          aaaa:  aaaaa,\n"
1868                "                          bbbb:  bbbbb,\n"
1869                "                        })}`;");
1870 }
1871 
1872 TEST_F(FormatTestJS, TemplateStringASI) {
1873   verifyFormat("var x = `hello${world}`;", "var x = `hello${\n"
1874                                            "    world\n"
1875                                            "}`;");
1876 }
1877 
1878 TEST_F(FormatTestJS, NestedTemplateStrings) {
1879   verifyFormat(
1880       "var x = `<ul>${xs.map(x => `<li>${x}</li>`).join('\\n')}</ul>`;");
1881   verifyFormat("var x = `he${({text: 'll'}.text)}o`;");
1882 
1883   // Crashed at some point.
1884   verifyFormat("}");
1885 }
1886 
1887 TEST_F(FormatTestJS, TaggedTemplateStrings) {
1888   verifyFormat("var x = html`<ul>`;");
1889   verifyFormat("yield `hello`;");
1890 }
1891 
1892 TEST_F(FormatTestJS, CastSyntax) {
1893   verifyFormat("var x = <type>foo;");
1894   verifyFormat("var x = foo as type;");
1895   verifyFormat("let x = (a + b) as\n"
1896                "    LongTypeIsLong;",
1897                getGoogleJSStyleWithColumns(20));
1898   verifyFormat("foo = <Bar[]>[\n"
1899                "  1,  //\n"
1900                "  2\n"
1901                "];");
1902   verifyFormat("var x = [{x: 1} as type];");
1903   verifyFormat("x = x as [a, b];");
1904   verifyFormat("x = x as {a: string};");
1905   verifyFormat("x = x as (string);");
1906   verifyFormat("x = x! as (string);");
1907   verifyFormat("var x = something.someFunction() as\n"
1908                "    something;",
1909                getGoogleJSStyleWithColumns(40));
1910 }
1911 
1912 TEST_F(FormatTestJS, TypeArguments) {
1913   verifyFormat("class X<Y> {}");
1914   verifyFormat("new X<Y>();");
1915   verifyFormat("foo<Y>(a);");
1916   verifyFormat("var x: X<Y>[];");
1917   verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
1918   verifyFormat("function f(a: List<any> = null) {}");
1919   verifyFormat("function f(): List<any> {}");
1920   verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
1921                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
1922   verifyFormat("function aaaaaaaaaa(\n"
1923                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
1924                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
1925                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
1926 }
1927 
1928 TEST_F(FormatTestJS, UserDefinedTypeGuards) {
1929   verifyFormat(
1930       "function foo(check: Object):\n"
1931       "    check is {foo: string, bar: string, baz: string, foobar: string} {\n"
1932       "  return 'bar' in check;\n"
1933       "}\n");
1934 }
1935 
1936 TEST_F(FormatTestJS, OptionalTypes) {
1937   verifyFormat("function x(a?: b, c?, d?) {}");
1938   verifyFormat("class X {\n"
1939                "  y?: z;\n"
1940                "  z?;\n"
1941                "}");
1942   verifyFormat("interface X {\n"
1943                "  y?(): z;\n"
1944                "}");
1945   verifyFormat("constructor({aa}: {\n"
1946                "  aa?: string,\n"
1947                "  aaaaaaaa?: string,\n"
1948                "  aaaaaaaaaaaaaaa?: boolean,\n"
1949                "  aaaaaa?: List<string>\n"
1950                "}) {}");
1951 }
1952 
1953 TEST_F(FormatTestJS, IndexSignature) {
1954   verifyFormat("var x: {[k: string]: v};");
1955 }
1956 
1957 TEST_F(FormatTestJS, WrapAfterParen) {
1958   verifyFormat("xxxxxxxxxxx(\n"
1959                "    aaa, aaa);",
1960                getGoogleJSStyleWithColumns(20));
1961   verifyFormat("xxxxxxxxxxx(\n"
1962                "    aaa, aaa, aaa,\n"
1963                "    aaa, aaa, aaa);",
1964                getGoogleJSStyleWithColumns(20));
1965   verifyFormat("xxxxxxxxxxx(\n"
1966                "    aaaaaaaaaaaaaaaaaaaaaaaa,\n"
1967                "    function(x) {\n"
1968                "      y();  //\n"
1969                "    });",
1970                getGoogleJSStyleWithColumns(40));
1971   verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
1972                "       bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
1973 }
1974 
1975 TEST_F(FormatTestJS, JSDocAnnotations) {
1976   verifyFormat("/**\n"
1977                " * @export {this.is.a.long.path.to.a.Type}\n"
1978                " */",
1979                "/**\n"
1980                " * @export {this.is.a.long.path.to.a.Type}\n"
1981                " */",
1982                getGoogleJSStyleWithColumns(20));
1983   verifyFormat("/**\n"
1984                " * @mods {this.is.a.long.path.to.a.Type}\n"
1985                " */",
1986                "/**\n"
1987                " * @mods {this.is.a.long.path.to.a.Type}\n"
1988                " */",
1989                getGoogleJSStyleWithColumns(20));
1990   verifyFormat("/**\n"
1991                " * @param {this.is.a.long.path.to.a.Type}\n"
1992                " */",
1993                "/**\n"
1994                " * @param {this.is.a.long.path.to.a.Type}\n"
1995                " */",
1996                getGoogleJSStyleWithColumns(20));
1997   verifyFormat("/**\n"
1998                " * @see http://very/very/long/url/is/long\n"
1999                " */",
2000                "/**\n"
2001                " * @see http://very/very/long/url/is/long\n"
2002                " */",
2003                getGoogleJSStyleWithColumns(20));
2004   verifyFormat(
2005       "/**\n"
2006       " * @param This is a\n"
2007       " * long comment but\n"
2008       " * no type\n"
2009       " */",
2010       "/**\n"
2011       " * @param This is a long comment but no type\n"
2012       " */",
2013       getGoogleJSStyleWithColumns(20));
2014   // Don't break @param line, but reindent it and reflow unrelated lines.
2015   verifyFormat("{\n"
2016                "  /**\n"
2017                "   * long long long\n"
2018                "   * long\n"
2019                "   * @param {this.is.a.long.path.to.a.Type} a\n"
2020                "   * long long long\n"
2021                "   * long long\n"
2022                "   */\n"
2023                "  function f(a) {}\n"
2024                "}",
2025                "{\n"
2026                "/**\n"
2027                " * long long long long\n"
2028                " * @param {this.is.a.long.path.to.a.Type} a\n"
2029                " * long long long long\n"
2030                " * long\n"
2031                " */\n"
2032                "  function f(a) {}\n"
2033                "}",
2034                getGoogleJSStyleWithColumns(20));
2035 }
2036 
2037 TEST_F(FormatTestJS, RequoteStringsSingle) {
2038   verifyFormat("var x = 'foo';", "var x = \"foo\";");
2039   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
2040   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
2041   verifyFormat(
2042       "var x =\n"
2043       "    'foo\\'';",
2044       // Code below is 15 chars wide, doesn't fit into the line with the
2045       // \ escape added.
2046       "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
2047   // Removes no-longer needed \ escape from ".
2048   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
2049   // Code below fits into 15 chars *after* removing the \ escape.
2050   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
2051                getGoogleJSStyleWithColumns(15));
2052   verifyFormat("// clang-format off\n"
2053                "let x = \"double\";\n"
2054                "// clang-format on\n"
2055                "let x = 'single';\n",
2056                "// clang-format off\n"
2057                "let x = \"double\";\n"
2058                "// clang-format on\n"
2059                "let x = \"single\";\n");
2060 }
2061 
2062 TEST_F(FormatTestJS, RequoteAndIndent) {
2063   verifyFormat("let x = someVeryLongFunctionThatGoesOnAndOn(\n"
2064                "    'double quoted string that needs wrapping');",
2065                "let x = someVeryLongFunctionThatGoesOnAndOn("
2066                "\"double quoted string that needs wrapping\");");
2067 
2068   verifyFormat("let x =\n"
2069                "    'foo\\'oo';\n"
2070                "let x =\n"
2071                "    'foo\\'oo';",
2072                "let x=\"foo'oo\";\n"
2073                "let x=\"foo'oo\";",
2074                getGoogleJSStyleWithColumns(15));
2075 }
2076 
2077 TEST_F(FormatTestJS, RequoteStringsDouble) {
2078   FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
2079   DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
2080   verifyFormat("var x = \"foo\";", DoubleQuotes);
2081   verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
2082   verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
2083 }
2084 
2085 TEST_F(FormatTestJS, RequoteStringsLeave) {
2086   FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
2087   LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
2088   verifyFormat("var x = \"foo\";", LeaveQuotes);
2089   verifyFormat("var x = 'foo';", LeaveQuotes);
2090 }
2091 
2092 TEST_F(FormatTestJS, SupportShebangLines) {
2093   verifyFormat("#!/usr/bin/env node\n"
2094                "var x = hello();",
2095                "#!/usr/bin/env node\n"
2096                "var x   =  hello();");
2097 }
2098 
2099 TEST_F(FormatTestJS, NonNullAssertionOperator) {
2100   verifyFormat("let x = foo!.bar();\n");
2101   verifyFormat("let x = foo ? bar! : baz;\n");
2102   verifyFormat("let x = !foo;\n");
2103   verifyFormat("let x = foo[0]!;\n");
2104   verifyFormat("let x = (foo)!;\n");
2105   verifyFormat("let x = x(foo!);\n");
2106   verifyFormat(
2107       "a.aaaaaa(a.a!).then(\n"
2108       "    x => x(x));\n",
2109       getGoogleJSStyleWithColumns(20));
2110   verifyFormat("let x = foo! - 1;\n");
2111   verifyFormat("let x = {foo: 1}!;\n");
2112   verifyFormat(
2113       "let x = hello.foo()!\n"
2114       "            .foo()!\n"
2115       "            .foo()!\n"
2116       "            .foo()!;\n",
2117       getGoogleJSStyleWithColumns(20));
2118   verifyFormat("let x = namespace!;\n");
2119   verifyFormat("return !!x;\n");
2120 }
2121 
2122 TEST_F(FormatTestJS, Conditional) {
2123   verifyFormat("y = x ? 1 : 2;");
2124   verifyFormat("x ? 1 : 2;");
2125   verifyFormat("class Foo {\n"
2126                "  field = true ? 1 : 2;\n"
2127                "  method(a = true ? 1 : 2) {}\n"
2128                "}");
2129 }
2130 
2131 TEST_F(FormatTestJS, ImportComments) {
2132   verifyFormat("import {x} from 'x';  // from some location",
2133                getGoogleJSStyleWithColumns(25));
2134   verifyFormat("// taze: x from 'location'", getGoogleJSStyleWithColumns(10));
2135   verifyFormat("/// <reference path=\"some/location\" />", getGoogleJSStyleWithColumns(10));
2136 }
2137 
2138 TEST_F(FormatTestJS, Exponentiation) {
2139   verifyFormat("squared = x ** 2;");
2140   verifyFormat("squared **= 2;");
2141 }
2142 
2143 TEST_F(FormatTestJS, NestedLiterals) {
2144   FormatStyle FourSpaces = getGoogleJSStyleWithColumns(15);
2145   FourSpaces.IndentWidth = 4;
2146   verifyFormat("var l = [\n"
2147                "    [\n"
2148                "        1,\n"
2149                "    ],\n"
2150                "];", FourSpaces);
2151   verifyFormat("var l = [\n"
2152                "    {\n"
2153                "        1: 1,\n"
2154                "    },\n"
2155                "];", FourSpaces);
2156   verifyFormat("someFunction(\n"
2157                "    p1,\n"
2158                "    [\n"
2159                "        1,\n"
2160                "    ],\n"
2161                ");", FourSpaces);
2162   verifyFormat("someFunction(\n"
2163                "    p1,\n"
2164                "    {\n"
2165                "        1: 1,\n"
2166                "    },\n"
2167                ");", FourSpaces);
2168   verifyFormat("var o = {\n"
2169                "    1: 1,\n"
2170                "    2: {\n"
2171                "        3: 3,\n"
2172                "    },\n"
2173                "};", FourSpaces);
2174   verifyFormat("var o = {\n"
2175                "    1: 1,\n"
2176                "    2: [\n"
2177                "        3,\n"
2178                "    ],\n"
2179                "};", FourSpaces);
2180 }
2181 
2182 TEST_F(FormatTestJS, BackslashesInComments) {
2183   verifyFormat("// hello \\\n"
2184                "if (x) foo();\n",
2185                "// hello \\\n"
2186                "     if ( x) \n"
2187                "   foo();\n");
2188   verifyFormat("/* ignore \\\n"
2189                " */\n"
2190                "if (x) foo();\n",
2191                "/* ignore \\\n"
2192                " */\n"
2193                " if (  x) foo();\n");
2194   verifyFormat("// st \\ art\\\n"
2195                "// comment"
2196                "// continue \\\n"
2197                "formatMe();\n",
2198                "// st \\ art\\\n"
2199                "// comment"
2200                "// continue \\\n"
2201                "formatMe( );\n");
2202 }
2203 
2204 } // end namespace tooling
2205 } // end namespace clang
2206