xref: /llvm-project/clang/unittests/Format/FormatTestJS.cpp (revision ddc80637ccbc5be26ae40f01841c6019a38d1955)
1 //===- unittest/Format/FormatTestJS.cpp - Formatting unit tests for JS ----===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "FormatTestUtils.h"
10 #include "clang/Format/Format.h"
11 #include "llvm/Support/Debug.h"
12 #include "gtest/gtest.h"
13 
14 #define DEBUG_TYPE "format-test"
15 
16 namespace clang {
17 namespace format {
18 
19 class FormatTestJS : public ::testing::Test {
20 protected:
21   static std::string format(llvm::StringRef Code, unsigned Offset,
22                             unsigned Length, const FormatStyle &Style) {
23     LLVM_DEBUG(llvm::errs() << "---\n");
24     LLVM_DEBUG(llvm::errs() << Code << "\n\n");
25     std::vector<tooling::Range> Ranges(1, tooling::Range(Offset, Length));
26     FormattingAttemptStatus Status;
27     tooling::Replacements Replaces =
28         reformat(Style, Code, Ranges, "<stdin>", &Status);
29     EXPECT_TRUE(Status.FormatComplete);
30     auto Result = applyAllReplacements(Code, Replaces);
31     EXPECT_TRUE(static_cast<bool>(Result));
32     LLVM_DEBUG(llvm::errs() << "\n" << *Result << "\n\n");
33     return *Result;
34   }
35 
36   static std::string format(
37       llvm::StringRef Code,
38       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
39     return format(Code, 0, Code.size(), Style);
40   }
41 
42   static FormatStyle getGoogleJSStyleWithColumns(unsigned ColumnLimit) {
43     FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
44     Style.ColumnLimit = ColumnLimit;
45     return Style;
46   }
47 
48   static void verifyFormat(
49       llvm::StringRef Code,
50       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
51     EXPECT_EQ(Code.str(), format(Code, Style)) << "Expected code is not stable";
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, llvm::StringRef Code,
58       const FormatStyle &Style = getGoogleStyle(FormatStyle::LK_JavaScript)) {
59     EXPECT_EQ(Expected.str(), format(Expected, Style))
60         << "Expected code is not stable";
61     std::string Result = format(Code, Style);
62     EXPECT_EQ(Expected.str(), Result) << "Formatted:\n" << Result;
63   }
64 };
65 
66 TEST_F(FormatTestJS, BlockComments) {
67   verifyFormat("/* aaaaaaaaaaaaa */ aaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
68                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
69   // Breaks after a single line block comment.
70   EXPECT_EQ("aaaaa = bbbb.ccccccccccccccc(\n"
71             "    /** @type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala} */\n"
72             "    mediaMessage);",
73             format("aaaaa = bbbb.ccccccccccccccc(\n"
74                    "    /** "
75                    "@type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala} */ "
76                    "mediaMessage);",
77                    getGoogleJSStyleWithColumns(70)));
78   // Breaks after a multiline block comment.
79   EXPECT_EQ(
80       "aaaaa = bbbb.ccccccccccccccc(\n"
81       "    /**\n"
82       "     * @type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala}\n"
83       "     */\n"
84       "    mediaMessage);",
85       format("aaaaa = bbbb.ccccccccccccccc(\n"
86              "    /**\n"
87              "     * @type_{!cccc.rrrrrrr.MMMMMMMMMMMM.LLLLLLLLLLL.lala}\n"
88              "     */ mediaMessage);",
89              getGoogleJSStyleWithColumns(70)));
90 }
91 
92 TEST_F(FormatTestJS, JSDocComments) {
93   // Break the first line of a multiline jsdoc comment.
94   EXPECT_EQ("/**\n"
95             " * jsdoc line 1\n"
96             " * jsdoc line 2\n"
97             " */",
98             format("/** jsdoc line 1\n"
99                    " * jsdoc line 2\n"
100                    " */",
101                    getGoogleJSStyleWithColumns(20)));
102   // Both break after '/**' and break the line itself.
103   EXPECT_EQ("/**\n"
104             " * jsdoc line long\n"
105             " * long jsdoc line 2\n"
106             " */",
107             format("/** jsdoc line long long\n"
108                    " * jsdoc line 2\n"
109                    " */",
110                    getGoogleJSStyleWithColumns(20)));
111   // Break a short first line if the ending '*/' is on a newline.
112   EXPECT_EQ("/**\n"
113             " * jsdoc line 1\n"
114             " */",
115             format("/** jsdoc line 1\n"
116                    " */",
117                    getGoogleJSStyleWithColumns(20)));
118   // Don't break the first line of a short single line jsdoc comment.
119   verifyFormat("/** jsdoc line 1 */", getGoogleJSStyleWithColumns(20));
120   // Don't break the first line of a single line jsdoc comment if it just fits
121   // the column limit.
122   verifyFormat("/** 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   verifyFormat("/** @returns j */", getGoogleJSStyleWithColumns(20));
185 
186   // Break a single line long jsdoc comment pragma.
187   EXPECT_EQ("/**\n"
188             " * @returns {string}\n"
189             " *     jsdoc line 12\n"
190             " */",
191             format("/** @returns {string} jsdoc line 12 */",
192                    getGoogleJSStyleWithColumns(20)));
193 
194   // FIXME: this overcounts the */ as a continuation of the 12 when breaking.
195   // Cf. BreakableBlockComment::getRemainingLength.
196   EXPECT_EQ("/**\n"
197             " * @returns {string}\n"
198             " *     jsdoc line line\n"
199             " *     12\n"
200             " */",
201             format("/** @returns {string} jsdoc line line 12*/",
202                    getGoogleJSStyleWithColumns(25)));
203 
204   // Fix a multiline jsdoc comment ending in a comment pragma.
205   EXPECT_EQ("/**\n"
206             " * line 1\n"
207             " * line 2\n"
208             " * @returns {string}\n"
209             " *     jsdoc line 12\n"
210             " */",
211             format("/** line 1\n"
212                    " * line 2\n"
213                    " * @returns {string} jsdoc line 12 */",
214                    getGoogleJSStyleWithColumns(20)));
215 
216   EXPECT_EQ("/**\n"
217             " * line 1\n"
218             " * line 2\n"
219             " *\n"
220             " * @returns j\n"
221             " */",
222             format("/** line 1\n"
223                    " * line 2\n"
224                    " *\n"
225                    " * @returns j */",
226                    getGoogleJSStyleWithColumns(20)));
227 }
228 
229 TEST_F(FormatTestJS, UnderstandsJavaScriptOperators) {
230   verifyFormat("a == = b;");
231   verifyFormat("a != = b;");
232 
233   verifyFormat("a === b;");
234   verifyFormat("aaaaaaa ===\n    b;", getGoogleJSStyleWithColumns(10));
235   verifyFormat("a !== b;");
236   verifyFormat("aaaaaaa !==\n    b;", getGoogleJSStyleWithColumns(10));
237   verifyFormat("if (a + b + c +\n"
238                "        d !==\n"
239                "    e + f + g)\n"
240                "  q();",
241                getGoogleJSStyleWithColumns(20));
242 
243   verifyFormat("a >> >= b;");
244 
245   verifyFormat("a >>> b;");
246   verifyFormat("aaaaaaa >>>\n    b;", getGoogleJSStyleWithColumns(10));
247   verifyFormat("a >>>= b;");
248   verifyFormat("aaaaaaa >>>=\n    b;", getGoogleJSStyleWithColumns(10));
249   verifyFormat("if (a + b + c +\n"
250                "        d >>>\n"
251                "    e + f + g)\n"
252                "  q();",
253                getGoogleJSStyleWithColumns(20));
254   verifyFormat("var x = aaaaaaaaaa ?\n"
255                "    bbbbbb :\n"
256                "    ccc;",
257                getGoogleJSStyleWithColumns(20));
258 
259   verifyFormat("var b = a.map((x) => x + 1);");
260   verifyFormat("return ('aaa') in bbbb;");
261   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
262                "    aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;");
263   FormatStyle Style = getGoogleJSStyleWithColumns(80);
264   Style.AlignOperands = FormatStyle::OAS_Align;
265   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa() in\n"
266                "        aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
267                Style);
268   Style.BreakBeforeBinaryOperators = FormatStyle::BOS_All;
269   verifyFormat("var x = aaaaaaaaaaaaaaaaaaaaaaaaa()\n"
270                "            in aaaa.aaaaaa.aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa;",
271                Style);
272 
273   // ES6 spread operator.
274   verifyFormat("someFunction(...a);");
275   verifyFormat("var x = [1, ...a, 2];");
276 
277   // "- -1" is legal JS syntax, but must not collapse into "--".
278   verifyFormat("- -1;", " - -1;");
279   verifyFormat("-- -1;", " -- -1;");
280   verifyFormat("+ +1;", " + +1;");
281   verifyFormat("++ +1;", " ++ +1;");
282 }
283 
284 TEST_F(FormatTestJS, UnderstandsAmpAmp) {
285   verifyFormat("e && e.SomeFunction();");
286 }
287 
288 TEST_F(FormatTestJS, LiteralOperatorsCanBeKeywords) {
289   verifyFormat("not.and.or.not_eq = 1;");
290 }
291 
292 TEST_F(FormatTestJS, ReservedWords) {
293   // JavaScript reserved words (aka keywords) are only illegal when used as
294   // Identifiers, but are legal as IdentifierNames.
295   verifyFormat("x.class.struct = 1;");
296   verifyFormat("x.case = 1;");
297   verifyFormat("x.interface = 1;");
298   verifyFormat("x.for = 1;");
299   verifyFormat("x.of();");
300   verifyFormat("of(null);");
301   verifyFormat("return of(null);");
302   verifyFormat("import {of} from 'x';");
303   verifyFormat("x.in();");
304   verifyFormat("x.let();");
305   verifyFormat("x.var();");
306   verifyFormat("x.for();");
307   verifyFormat("x.as();");
308   verifyFormat("x.instanceof();");
309   verifyFormat("x.switch();");
310   verifyFormat("x.case();");
311   verifyFormat("x.delete();");
312   verifyFormat("x.throw();");
313   verifyFormat("x.throws();");
314   verifyFormat("x.if();");
315   verifyFormat("x = {\n"
316                "  a: 12,\n"
317                "  interface: 1,\n"
318                "  switch: 1,\n"
319                "};");
320   verifyFormat("var struct = 2;");
321   verifyFormat("var union = 2;");
322   verifyFormat("var interface = 2;");
323   verifyFormat("var requires = {};");
324   verifyFormat("interface = 2;");
325   verifyFormat("x = interface instanceof y;");
326   verifyFormat("interface Test {\n"
327                "  x: string;\n"
328                "  switch: string;\n"
329                "  case: string;\n"
330                "  default: string;\n"
331                "}\n");
332   verifyFormat("const Axis = {\n"
333                "  for: 'for',\n"
334                "  x: 'x'\n"
335                "};",
336                "const Axis = {for: 'for', x:   'x'};");
337   verifyFormat("export class Foo extends Bar {\n"
338                "  get case(): Case {\n"
339                "    return (\n"
340                "        (this.Bar$has('case')) ? (this.Bar$get('case')) :\n"
341                "                                 (this.case = new Case()));\n"
342                "  }\n"
343                "}");
344 }
345 
346 TEST_F(FormatTestJS, ReservedWordsMethods) {
347   verifyFormat("class X {\n"
348                "  delete() {\n"
349                "    x();\n"
350                "  }\n"
351                "  interface() {\n"
352                "    x();\n"
353                "  }\n"
354                "  let() {\n"
355                "    x();\n"
356                "  }\n"
357                "}\n");
358   verifyFormat("class KeywordNamedMethods {\n"
359                "  do() {\n"
360                "  }\n"
361                "  for() {\n"
362                "  }\n"
363                "  while() {\n"
364                "  }\n"
365                "  if() {\n"
366                "  }\n"
367                "  else() {\n"
368                "  }\n"
369                "  try() {\n"
370                "  }\n"
371                "  catch() {\n"
372                "  }\n"
373                "}\n");
374 }
375 
376 TEST_F(FormatTestJS, ReservedWordsParenthesized) {
377   // All of these are statements using the keyword, not function calls.
378   verifyFormat("throw (x + y);\n"
379                "await (await x).y;\n"
380                "typeof (x) === 'string';\n"
381                "void (0);\n"
382                "delete (x.y);\n"
383                "return (x);\n");
384 }
385 
386 TEST_F(FormatTestJS, ES6DestructuringAssignment) {
387   verifyFormat("var [a, b, c] = [1, 2, 3];");
388   verifyFormat("const [a, b, c] = [1, 2, 3];");
389   verifyFormat("let [a, b, c] = [1, 2, 3];");
390   verifyFormat("var {a, b} = {a: 1, b: 2};");
391   verifyFormat("let {a, b} = {a: 1, b: 2};");
392 }
393 
394 TEST_F(FormatTestJS, ContainerLiterals) {
395   verifyFormat("var x = {\n"
396                "  y: function(a) {\n"
397                "    return a;\n"
398                "  }\n"
399                "};");
400   verifyFormat("return {\n"
401                "  link: function() {\n"
402                "    f();  //\n"
403                "  }\n"
404                "};");
405   verifyFormat("return {\n"
406                "  a: a,\n"
407                "  link: function() {\n"
408                "    f();  //\n"
409                "  }\n"
410                "};");
411   verifyFormat("return {\n"
412                "  a: a,\n"
413                "  link: function() {\n"
414                "    f();  //\n"
415                "  },\n"
416                "  link: function() {\n"
417                "    f();  //\n"
418                "  }\n"
419                "};");
420   verifyFormat("var stuff = {\n"
421                "  // comment for update\n"
422                "  update: false,\n"
423                "  // comment for modules\n"
424                "  modules: false,\n"
425                "  // comment for tasks\n"
426                "  tasks: false\n"
427                "};");
428   verifyFormat("return {\n"
429                "  'finish':\n"
430                "      //\n"
431                "      a\n"
432                "};");
433   verifyFormat("var obj = {\n"
434                "  fooooooooo: function(x) {\n"
435                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
436                "  }\n"
437                "};");
438   // Simple object literal, as opposed to enum style below.
439   verifyFormat("var obj = {a: 123};");
440   // Enum style top level assignment.
441   verifyFormat("X = {\n  a: 123\n};");
442   verifyFormat("X.Y = {\n  a: 123\n};");
443   // But only on the top level, otherwise its a plain object literal assignment.
444   verifyFormat("function x() {\n"
445                "  y = {z: 1};\n"
446                "}");
447   verifyFormat("x = foo && {a: 123};");
448 
449   // Arrow functions in object literals.
450   verifyFormat("var x = {\n"
451                "  y: (a) => {\n"
452                "    x();\n"
453                "    return a;\n"
454                "  },\n"
455                "};");
456   verifyFormat("var x = {y: (a) => a};");
457 
458   // Methods in object literals.
459   verifyFormat("var x = {\n"
460                "  y(a: string): number {\n"
461                "    return a;\n"
462                "  }\n"
463                "};");
464   verifyFormat("var x = {\n"
465                "  y(a: string) {\n"
466                "    return a;\n"
467                "  }\n"
468                "};");
469 
470   // Computed keys.
471   verifyFormat("var x = {[a]: 1, b: 2, [c]: 3};");
472   verifyFormat("var x = {\n"
473                "  [a]: 1,\n"
474                "  b: 2,\n"
475                "  [c]: 3,\n"
476                "};");
477 
478   // Object literals can leave out labels.
479   verifyFormat("f({a}, () => {\n"
480                "  x;\n"
481                "  g();\n"
482                "});");
483 
484   // Keys can be quoted.
485   verifyFormat("var x = {\n"
486                "  a: a,\n"
487                "  b: b,\n"
488                "  'c': c,\n"
489                "};");
490 
491   // Dict literals can skip the label names.
492   verifyFormat("var x = {\n"
493                "  aaa,\n"
494                "  aaa,\n"
495                "  aaa,\n"
496                "};");
497   verifyFormat("return {\n"
498                "  a,\n"
499                "  b: 'b',\n"
500                "  c,\n"
501                "};");
502 }
503 
504 TEST_F(FormatTestJS, MethodsInObjectLiterals) {
505   verifyFormat("var o = {\n"
506                "  value: 'test',\n"
507                "  get value() {  // getter\n"
508                "    return this.value;\n"
509                "  }\n"
510                "};");
511   verifyFormat("var o = {\n"
512                "  value: 'test',\n"
513                "  set value(val) {  // setter\n"
514                "    this.value = val;\n"
515                "  }\n"
516                "};");
517   verifyFormat("var o = {\n"
518                "  value: 'test',\n"
519                "  someMethod(val) {  // method\n"
520                "    doSomething(this.value + val);\n"
521                "  }\n"
522                "};");
523   verifyFormat("var o = {\n"
524                "  someMethod(val) {  // method\n"
525                "    doSomething(this.value + val);\n"
526                "  },\n"
527                "  someOtherMethod(val) {  // method\n"
528                "    doSomething(this.value + val);\n"
529                "  }\n"
530                "};");
531 }
532 
533 TEST_F(FormatTestJS, GettersSettersVisibilityKeywords) {
534   // Don't break after "protected"
535   verifyFormat("class X {\n"
536                "  protected get getter():\n"
537                "      number {\n"
538                "    return 1;\n"
539                "  }\n"
540                "}",
541                getGoogleJSStyleWithColumns(12));
542   // Don't break after "get"
543   verifyFormat("class X {\n"
544                "  protected get someReallyLongGetterName():\n"
545                "      number {\n"
546                "    return 1;\n"
547                "  }\n"
548                "}",
549                getGoogleJSStyleWithColumns(40));
550 }
551 
552 TEST_F(FormatTestJS, SpacesInContainerLiterals) {
553   verifyFormat("var arr = [1, 2, 3];");
554   verifyFormat("f({a: 1, b: 2, c: 3});");
555 
556   verifyFormat("var object_literal_with_long_name = {\n"
557                "  a: 'aaaaaaaaaaaaaaaaaa',\n"
558                "  b: 'bbbbbbbbbbbbbbbbbb'\n"
559                "};");
560 
561   verifyFormat("f({a: 1, b: 2, c: 3});",
562                getChromiumStyle(FormatStyle::LK_JavaScript));
563   verifyFormat("f({'a': [{}]});");
564 }
565 
566 TEST_F(FormatTestJS, SingleQuotedStrings) {
567   verifyFormat("this.function('', true);");
568 }
569 
570 TEST_F(FormatTestJS, GoogScopes) {
571   verifyFormat("goog.scope(function() {\n"
572                "var x = a.b;\n"
573                "var y = c.d;\n"
574                "});  // goog.scope");
575   verifyFormat("goog.scope(function() {\n"
576                "// test\n"
577                "var x = 0;\n"
578                "// test\n"
579                "});");
580 }
581 
582 TEST_F(FormatTestJS, IIFEs) {
583   // Internal calling parens; no semi.
584   verifyFormat("(function() {\n"
585                "var a = 1;\n"
586                "}())");
587   // External calling parens; no semi.
588   verifyFormat("(function() {\n"
589                "var b = 2;\n"
590                "})()");
591   // Internal calling parens; with semi.
592   verifyFormat("(function() {\n"
593                "var c = 3;\n"
594                "}());");
595   // External calling parens; with semi.
596   verifyFormat("(function() {\n"
597                "var d = 4;\n"
598                "})();");
599 }
600 
601 TEST_F(FormatTestJS, GoogModules) {
602   verifyFormat("goog.module('this.is.really.absurdly.long');",
603                getGoogleJSStyleWithColumns(40));
604   verifyFormat("goog.require('this.is.really.absurdly.long');",
605                getGoogleJSStyleWithColumns(40));
606   verifyFormat("goog.provide('this.is.really.absurdly.long');",
607                getGoogleJSStyleWithColumns(40));
608   verifyFormat("var long = goog.require('this.is.really.absurdly.long');",
609                getGoogleJSStyleWithColumns(40));
610   verifyFormat("const X = goog.requireType('this.is.really.absurdly.long');",
611                getGoogleJSStyleWithColumns(40));
612   verifyFormat("goog.forwardDeclare('this.is.really.absurdly.long');",
613                getGoogleJSStyleWithColumns(40));
614 
615   // These should be wrapped normally.
616   verifyFormat(
617       "var MyLongClassName =\n"
618       "    goog.module.get('my.long.module.name.followedBy.MyLongClassName');");
619   verifyFormat("function a() {\n"
620                "  goog.setTestOnly();\n"
621                "}\n",
622                "function a() {\n"
623                "goog.setTestOnly();\n"
624                "}\n");
625 }
626 
627 TEST_F(FormatTestJS, FormatsNamespaces) {
628   verifyFormat("namespace Foo {\n"
629                "  export let x = 1;\n"
630                "}\n");
631   verifyFormat("declare namespace Foo {\n"
632                "  export let x: number;\n"
633                "}\n");
634 }
635 
636 TEST_F(FormatTestJS, NamespacesMayNotWrap) {
637   verifyFormat("declare namespace foobarbaz {\n"
638                "}\n",
639                getGoogleJSStyleWithColumns(18));
640   verifyFormat("declare module foobarbaz {\n"
641                "}\n",
642                getGoogleJSStyleWithColumns(15));
643   verifyFormat("namespace foobarbaz {\n"
644                "}\n",
645                getGoogleJSStyleWithColumns(10));
646   verifyFormat("module foobarbaz {\n"
647                "}\n",
648                getGoogleJSStyleWithColumns(7));
649 }
650 
651 TEST_F(FormatTestJS, AmbientDeclarations) {
652   FormatStyle NineCols = getGoogleJSStyleWithColumns(9);
653   verifyFormat("declare class\n"
654                "    X {}",
655                NineCols);
656   verifyFormat("declare function\n"
657                "x();", // TODO(martinprobst): should ideally be indented.
658                NineCols);
659   verifyFormat("declare function foo();\n"
660                "let x = 1;\n");
661   verifyFormat("declare function foo(): string;\n"
662                "let x = 1;\n");
663   verifyFormat("declare function foo(): {x: number};\n"
664                "let x = 1;\n");
665   verifyFormat("declare class X {}\n"
666                "let x = 1;\n");
667   verifyFormat("declare interface Y {}\n"
668                "let x = 1;\n");
669   verifyFormat("declare enum X {\n"
670                "}",
671                NineCols);
672   verifyFormat("declare let\n"
673                "    x: number;",
674                NineCols);
675 }
676 
677 TEST_F(FormatTestJS, FormatsFreestandingFunctions) {
678   verifyFormat("function outer1(a, b) {\n"
679                "  function inner1(a, b) {\n"
680                "    return a;\n"
681                "  }\n"
682                "  inner1(a, b);\n"
683                "}\n"
684                "function outer2(a, b) {\n"
685                "  function inner2(a, b) {\n"
686                "    return a;\n"
687                "  }\n"
688                "  inner2(a, b);\n"
689                "}");
690   verifyFormat("function f() {}");
691   verifyFormat("function aFunction() {}\n"
692                "(function f() {\n"
693                "  var x = 1;\n"
694                "}());\n");
695   verifyFormat("function aFunction() {}\n"
696                "{\n"
697                "  let x = 1;\n"
698                "  console.log(x);\n"
699                "}\n");
700   EXPECT_EQ("a = function(x) {}\n"
701             "\n"
702             "function f(x) {}",
703             format("a = function(x) {}\n"
704                    "\n"
705                    "function f(x) {}",
706                    getGoogleJSStyleWithColumns(20)));
707 }
708 
709 TEST_F(FormatTestJS, FormatsDecorators) {
710   // No line break after argument decorators.
711   verifyFormat("class A {\n"
712                "  constructor(@arg(DECOR) private arg: Type) {}\n"
713                "}");
714   // Ensure that there is a break before functions, getters and setters.
715   EXPECT_EQ("class A {\n"
716             "  private p = () => {}\n"
717             "\n"
718             "  @decorated('a')\n"
719             "  get f() {\n"
720             "    return result;\n"
721             "  }\n"
722             "}\n"
723             "\n"
724             "class B {\n"
725             "  private p = () => {}\n"
726             "\n"
727             "  @decorated('a')\n"
728             "  set f() {\n"
729             "    return result;\n"
730             "  }\n"
731             "}\n"
732             "\n"
733             "class C {\n"
734             "  private p = () => {}\n"
735             "\n"
736             "  @decorated('a')\n"
737             "  function f() {\n"
738             "    return result;\n"
739             "  }\n"
740             "}",
741             format("class A {\n"
742                    "  private p = () => {}\n"
743                    "\n"
744                    "  @decorated('a')\n"
745                    "  get f() {\n"
746                    "    return result;\n"
747                    "  }\n"
748                    "}\n"
749                    "\n"
750                    "class B {\n"
751                    "  private p = () => {}\n"
752                    "\n"
753                    "  @decorated('a')\n"
754                    "  set f() {\n"
755                    "    return result;\n"
756                    "  }\n"
757                    "}\n"
758                    "\n"
759                    "class C {\n"
760                    "  private p = () => {}\n"
761                    "\n"
762                    "  @decorated('a')\n"
763                    "  function f() {\n"
764                    "    return result;\n"
765                    "  }\n"
766                    "}",
767                    getGoogleJSStyleWithColumns(50)));
768 }
769 
770 TEST_F(FormatTestJS, GeneratorFunctions) {
771   verifyFormat("function* f() {\n"
772                "  let x = 1;\n"
773                "  yield x;\n"
774                "  yield* something();\n"
775                "  yield [1, 2];\n"
776                "  yield {a: 1};\n"
777                "}");
778   verifyFormat("function*\n"
779                "    f() {\n"
780                "}",
781                getGoogleJSStyleWithColumns(8));
782   verifyFormat("export function* f() {\n"
783                "  yield 1;\n"
784                "}\n");
785   verifyFormat("class X {\n"
786                "  * generatorMethod() {\n"
787                "    yield x;\n"
788                "  }\n"
789                "}");
790   verifyFormat("var x = {\n"
791                "  a: function*() {\n"
792                "    //\n"
793                "  }\n"
794                "}\n");
795 }
796 
797 TEST_F(FormatTestJS, AsyncFunctions) {
798   verifyFormat("async function f() {\n"
799                "  let x = 1;\n"
800                "  return fetch(x);\n"
801                "}");
802   verifyFormat("async function f() {\n"
803                "  return 1;\n"
804                "}\n"
805                "\n"
806                "function a() {\n"
807                "  return 1;\n"
808                "}\n",
809                "  async   function f() {\n"
810                "   return 1;\n"
811                "}\n"
812                "\n"
813                "   function a() {\n"
814                "  return   1;\n"
815                "}  \n");
816   // clang-format must not insert breaks between async and function, otherwise
817   // automatic semicolon insertion may trigger (in particular in a class body).
818   verifyFormat("async function\n"
819                "hello(\n"
820                "    myparamnameiswaytooloooong) {\n"
821                "}",
822                "async function hello(myparamnameiswaytooloooong) {}",
823                getGoogleJSStyleWithColumns(10));
824   verifyFormat("class C {\n"
825                "  async hello(\n"
826                "      myparamnameiswaytooloooong) {\n"
827                "  }\n"
828                "}",
829                "class C {\n"
830                "  async hello(myparamnameiswaytooloooong) {} }",
831                getGoogleJSStyleWithColumns(10));
832   verifyFormat("async function* f() {\n"
833                "  yield fetch(x);\n"
834                "}");
835   verifyFormat("export async function f() {\n"
836                "  return fetch(x);\n"
837                "}");
838   verifyFormat("let x = async () => f();");
839   verifyFormat("let x = async function() {\n"
840                "  f();\n"
841                "};");
842   verifyFormat("let x = async();");
843   verifyFormat("class X {\n"
844                "  async asyncMethod() {\n"
845                "    return fetch(1);\n"
846                "  }\n"
847                "}");
848   verifyFormat("function initialize() {\n"
849                "  // Comment.\n"
850                "  return async.then();\n"
851                "}\n");
852   verifyFormat("for await (const x of y) {\n"
853                "  console.log(x);\n"
854                "}\n");
855   verifyFormat("function asyncLoop() {\n"
856                "  for await (const x of y) {\n"
857                "    console.log(x);\n"
858                "  }\n"
859                "}\n");
860 }
861 
862 TEST_F(FormatTestJS, OverriddenMembers) {
863   verifyFormat(
864       "class C extends P {\n"
865       "  protected override "
866       "anOverlyLongPropertyNameSoLongItHasToGoInASeparateLineWhenOverriden:\n"
867       "      undefined;\n"
868       "}\n");
869   verifyFormat(
870       "class C extends P {\n"
871       "  protected override "
872       "anOverlyLongMethodNameSoLongItHasToGoInASeparateLineWhenOverriden() {\n"
873       "  }\n"
874       "}\n");
875   verifyFormat("class C extends P {\n"
876                "  protected override aMethodName<ATypeParam extends {},\n"
877                "                                                    BTypeParam "
878                "extends {}>() {}\n"
879                "}\n");
880 }
881 
882 TEST_F(FormatTestJS, FunctionParametersTrailingComma) {
883   verifyFormat("function trailingComma(\n"
884                "    p1,\n"
885                "    p2,\n"
886                "    p3,\n"
887                ") {\n"
888                "  a;  //\n"
889                "}\n",
890                "function trailingComma(p1, p2, p3,) {\n"
891                "  a;  //\n"
892                "}\n");
893   verifyFormat("trailingComma(\n"
894                "    p1,\n"
895                "    p2,\n"
896                "    p3,\n"
897                ");\n",
898                "trailingComma(p1, p2, p3,);\n");
899   verifyFormat("trailingComma(\n"
900                "    p1  // hello\n"
901                ");\n",
902                "trailingComma(p1 // hello\n"
903                ");\n");
904 }
905 
906 TEST_F(FormatTestJS, ArrayLiterals) {
907   verifyFormat("var aaaaa: List<SomeThing> =\n"
908                "    [new SomeThingAAAAAAAAAAAA(), new SomeThingBBBBBBBBB()];");
909   verifyFormat("return [\n"
910                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
911                "  ccccccccccccccccccccccccccc\n"
912                "];");
913   verifyFormat("return [\n"
914                "  aaaa().bbbbbbbb('A'),\n"
915                "  aaaa().bbbbbbbb('B'),\n"
916                "  aaaa().bbbbbbbb('C'),\n"
917                "];");
918   verifyFormat("var someVariable = SomeFunction([\n"
919                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
920                "  ccccccccccccccccccccccccccc\n"
921                "]);");
922   verifyFormat("var someVariable = SomeFunction([\n"
923                "  [aaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbb],\n"
924                "]);",
925                getGoogleJSStyleWithColumns(51));
926   verifyFormat("var someVariable = SomeFunction(aaaa, [\n"
927                "  aaaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
928                "  ccccccccccccccccccccccccccc\n"
929                "]);");
930   verifyFormat("var someVariable = SomeFunction(\n"
931                "    aaaa,\n"
932                "    [\n"
933                "      aaaaaaaaaaaaaaaaaaaaaaaaaa, bbbbbbbbbbbbbbbbbbbbbbbbbb,\n"
934                "      cccccccccccccccccccccccccc\n"
935                "    ],\n"
936                "    aaaa);");
937   verifyFormat("var aaaa = aaaaa ||  // wrap\n"
938                "    [];");
939 
940   verifyFormat("someFunction([], {a: a});");
941 
942   verifyFormat("var string = [\n"
943                "  'aaaaaa',\n"
944                "  'bbbbbb',\n"
945                "].join('+');");
946 }
947 
948 TEST_F(FormatTestJS, ColumnLayoutForArrayLiterals) {
949   verifyFormat("var array = [\n"
950                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
951                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
952                "];");
953   verifyFormat("var array = someFunction([\n"
954                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
955                "  a, a, a, a, a, a, a, a, a, a, a, a, a, a, a,\n"
956                "]);");
957 }
958 
959 TEST_F(FormatTestJS, TrailingCommaInsertion) {
960   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
961   Style.InsertTrailingCommas = FormatStyle::TCS_Wrapped;
962   // Insert comma in wrapped array.
963   verifyFormat("const x = [\n"
964                "  1,  //\n"
965                "  2,\n"
966                "];",
967                "const x = [\n"
968                "  1,  //\n"
969                "  2];",
970                Style);
971   // Insert comma in newly wrapped array.
972   Style.ColumnLimit = 30;
973   verifyFormat("const x = [\n"
974                "  aaaaaaaaaaaaaaaaaaaaaaaaa,\n"
975                "];",
976                "const x = [aaaaaaaaaaaaaaaaaaaaaaaaa];", Style);
977   // Do not insert trailing commas if they'd exceed the colum limit
978   verifyFormat("const x = [\n"
979                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaa\n"
980                "];",
981                "const x = [aaaaaaaaaaaaaaaaaaaaaaaaaaaa];", Style);
982   // Object literals.
983   verifyFormat("const x = {\n"
984                "  a: aaaaaaaaaaaaaaaaa,\n"
985                "};",
986                "const x = {a: aaaaaaaaaaaaaaaaa};", Style);
987   verifyFormat("const x = {\n"
988                "  a: aaaaaaaaaaaaaaaaaaaaaaaaa\n"
989                "};",
990                "const x = {a: aaaaaaaaaaaaaaaaaaaaaaaaa};", Style);
991   // Object literal types.
992   verifyFormat("let x: {\n"
993                "  a: aaaaaaaaaaaaaaaaaaaaa,\n"
994                "};",
995                "let x: {a: aaaaaaaaaaaaaaaaaaaaa};", Style);
996 }
997 
998 TEST_F(FormatTestJS, FunctionLiterals) {
999   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
1000   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
1001   verifyFormat("doFoo(function() {});");
1002   verifyFormat("doFoo(function() { return 1; });", Style);
1003   verifyFormat("var func = function() {\n"
1004                "  return 1;\n"
1005                "};");
1006   verifyFormat("var func =  //\n"
1007                "    function() {\n"
1008                "  return 1;\n"
1009                "};");
1010   verifyFormat("return {\n"
1011                "  body: {\n"
1012                "    setAttribute: function(key, val) { this[key] = val; },\n"
1013                "    getAttribute: function(key) { return this[key]; },\n"
1014                "    style: {direction: ''}\n"
1015                "  }\n"
1016                "};",
1017                Style);
1018   verifyFormat("abc = xyz ? function() {\n"
1019                "  return 1;\n"
1020                "} : function() {\n"
1021                "  return -1;\n"
1022                "};");
1023 
1024   verifyFormat("var closure = goog.bind(\n"
1025                "    function() {  // comment\n"
1026                "      foo();\n"
1027                "      bar();\n"
1028                "    },\n"
1029                "    this, arg1IsReallyLongAndNeedsLineBreaks,\n"
1030                "    arg3IsReallyLongAndNeedsLineBreaks);");
1031   verifyFormat("var closure = goog.bind(function() {  // comment\n"
1032                "  foo();\n"
1033                "  bar();\n"
1034                "}, this);");
1035   verifyFormat("return {\n"
1036                "  a: 'E',\n"
1037                "  b: function() {\n"
1038                "    return function() {\n"
1039                "      f();  //\n"
1040                "    };\n"
1041                "  }\n"
1042                "};");
1043   verifyFormat("{\n"
1044                "  var someVariable = function(x) {\n"
1045                "    return x.zIsTooLongForOneLineWithTheDeclarationLine();\n"
1046                "  };\n"
1047                "}");
1048   verifyFormat("someLooooooooongFunction(\n"
1049                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1050                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1051                "    function(aaaaaaaaaaaaaaaaaaaaaaaaaaaaa) {\n"
1052                "      // code\n"
1053                "    });");
1054 
1055   verifyFormat("return {\n"
1056                "  a: function SomeFunction() {\n"
1057                "    // ...\n"
1058                "    return 1;\n"
1059                "  }\n"
1060                "};");
1061   verifyFormat("this.someObject.doSomething(aaaaaaaaaaaaaaaaaaaaaaaaaa)\n"
1062                "    .then(goog.bind(function(aaaaaaaaaaa) {\n"
1063                "      someFunction();\n"
1064                "      someFunction();\n"
1065                "    }, this), aaaaaaaaaaaaaaaaa);");
1066 
1067   verifyFormat("someFunction(goog.bind(function() {\n"
1068                "  doSomething();\n"
1069                "  doSomething();\n"
1070                "}, this), goog.bind(function() {\n"
1071                "  doSomething();\n"
1072                "  doSomething();\n"
1073                "}, this));");
1074 
1075   verifyFormat("SomeFunction(function() {\n"
1076                "  foo();\n"
1077                "  bar();\n"
1078                "}.bind(this));");
1079 
1080   verifyFormat("SomeFunction((function() {\n"
1081                "               foo();\n"
1082                "               bar();\n"
1083                "             }).bind(this));");
1084 
1085   // FIXME: This is bad, we should be wrapping before "function() {".
1086   verifyFormat("someFunction(function() {\n"
1087                "  doSomething();  // break\n"
1088                "})\n"
1089                "    .doSomethingElse(\n"
1090                "        // break\n"
1091                "    );");
1092 
1093   Style.ColumnLimit = 33;
1094   verifyFormat("f({a: function() { return 1; }});", Style);
1095   Style.ColumnLimit = 32;
1096   verifyFormat("f({\n"
1097                "  a: function() { return 1; }\n"
1098                "});",
1099                Style);
1100 }
1101 
1102 TEST_F(FormatTestJS, DontWrapEmptyLiterals) {
1103   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
1104                "    .and.returnValue(Observable.of([]));");
1105   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
1106                "    .and.returnValue(Observable.of({}));");
1107   verifyFormat("(aaaaaaaaaaaaaaaaaaaaa.getData as jasmine.Spy)\n"
1108                "    .and.returnValue(Observable.of(()));");
1109 }
1110 
1111 TEST_F(FormatTestJS, InliningFunctionLiterals) {
1112   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
1113   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Inline;
1114   verifyFormat("var func = function() {\n"
1115                "  return 1;\n"
1116                "};",
1117                Style);
1118   verifyFormat("var func = doSomething(function() { return 1; });", Style);
1119   verifyFormat("var outer = function() {\n"
1120                "  var inner = function() { return 1; }\n"
1121                "};",
1122                Style);
1123   verifyFormat("function outer1(a, b) {\n"
1124                "  function inner1(a, b) { return a; }\n"
1125                "}",
1126                Style);
1127 
1128   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
1129   verifyFormat("var func = function() { return 1; };", Style);
1130   verifyFormat("var func = doSomething(function() { return 1; });", Style);
1131   verifyFormat(
1132       "var outer = function() { var inner = function() { return 1; } };",
1133       Style);
1134   verifyFormat("function outer1(a, b) {\n"
1135                "  function inner1(a, b) { return a; }\n"
1136                "}",
1137                Style);
1138 
1139   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_None;
1140   verifyFormat("var func = function() {\n"
1141                "  return 1;\n"
1142                "};",
1143                Style);
1144   verifyFormat("var func = doSomething(function() {\n"
1145                "  return 1;\n"
1146                "});",
1147                Style);
1148   verifyFormat("var outer = function() {\n"
1149                "  var inner = function() {\n"
1150                "    return 1;\n"
1151                "  }\n"
1152                "};",
1153                Style);
1154   verifyFormat("function outer1(a, b) {\n"
1155                "  function inner1(a, b) {\n"
1156                "    return a;\n"
1157                "  }\n"
1158                "}",
1159                Style);
1160 
1161   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_Empty;
1162   verifyFormat("var func = function() {\n"
1163                "  return 1;\n"
1164                "};",
1165                Style);
1166 }
1167 
1168 TEST_F(FormatTestJS, MultipleFunctionLiterals) {
1169   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
1170   Style.AllowShortFunctionsOnASingleLine = FormatStyle::SFS_All;
1171   verifyFormat("promise.then(\n"
1172                "    function success() {\n"
1173                "      doFoo();\n"
1174                "      doBar();\n"
1175                "    },\n"
1176                "    function error() {\n"
1177                "      doFoo();\n"
1178                "      doBaz();\n"
1179                "    },\n"
1180                "    []);\n");
1181   verifyFormat("promise.then(\n"
1182                "    function success() {\n"
1183                "      doFoo();\n"
1184                "      doBar();\n"
1185                "    },\n"
1186                "    [],\n"
1187                "    function error() {\n"
1188                "      doFoo();\n"
1189                "      doBaz();\n"
1190                "    });\n");
1191   verifyFormat("promise.then(\n"
1192                "    [],\n"
1193                "    function success() {\n"
1194                "      doFoo();\n"
1195                "      doBar();\n"
1196                "    },\n"
1197                "    function error() {\n"
1198                "      doFoo();\n"
1199                "      doBaz();\n"
1200                "    });\n");
1201 
1202   verifyFormat("getSomeLongPromise()\n"
1203                "    .then(function(value) { body(); })\n"
1204                "    .thenCatch(function(error) {\n"
1205                "      body();\n"
1206                "      body();\n"
1207                "    });",
1208                Style);
1209   verifyFormat("getSomeLongPromise()\n"
1210                "    .then(function(value) {\n"
1211                "      body();\n"
1212                "      body();\n"
1213                "    })\n"
1214                "    .thenCatch(function(error) {\n"
1215                "      body();\n"
1216                "      body();\n"
1217                "    });");
1218 
1219   verifyFormat("getSomeLongPromise()\n"
1220                "    .then(function(value) { body(); })\n"
1221                "    .thenCatch(function(error) { body(); });",
1222                Style);
1223 
1224   verifyFormat("return [aaaaaaaaaaaaaaaaaaaaaa]\n"
1225                "    .aaaaaaa(function() {\n"
1226                "      //\n"
1227                "    })\n"
1228                "    .bbbbbb();");
1229 }
1230 
1231 TEST_F(FormatTestJS, ArrowFunctions) {
1232   verifyFormat("var x = (a) => {\n"
1233                "  x;\n"
1234                "  return a;\n"
1235                "};\n");
1236   verifyFormat("var x = (a) => {\n"
1237                "  function y() {\n"
1238                "    return 42;\n"
1239                "  }\n"
1240                "  return a;\n"
1241                "};");
1242   verifyFormat("var x = (a: type): {some: type} => {\n"
1243                "  y;\n"
1244                "  return a;\n"
1245                "};");
1246   verifyFormat("var x = (a) => a;");
1247   verifyFormat("return () => [];");
1248   verifyFormat("var aaaaaaaaaaaaaaaaaaaa = {\n"
1249                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaa:\n"
1250                "      (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1251                "       aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa) =>\n"
1252                "          aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
1253                "};");
1254   verifyFormat("var a = a.aaaaaaa(\n"
1255                "    (a: a) => aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) &&\n"
1256                "        aaaaaaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
1257   verifyFormat("var a = a.aaaaaaa(\n"
1258                "    (a: a) => aaaaaaaaaaaaaaaaaaaaa(bbbbbbbbb) ?\n"
1259                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb) :\n"
1260                "        aaaaaaaaaaaaaaaaaaaaa(bbbbbbb));");
1261 
1262   // FIXME: This is bad, we should be wrapping before "() => {".
1263   verifyFormat("someFunction(() => {\n"
1264                "  doSomething();  // break\n"
1265                "})\n"
1266                "    .doSomethingElse(\n"
1267                "        // break\n"
1268                "    );");
1269   verifyFormat("const f = (x: string|null): string|null => {\n"
1270                "  y;\n"
1271                "  return x;\n"
1272                "}\n");
1273 }
1274 
1275 TEST_F(FormatTestJS, ArrowFunctionStyle) {
1276   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
1277   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_All;
1278   verifyFormat("const arr = () => { x; };", Style);
1279   verifyFormat("const arrInlineAll = () => {};", Style);
1280   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_None;
1281   verifyFormat("const arr = () => {\n"
1282                "  x;\n"
1283                "};",
1284                Style);
1285   verifyFormat("const arrInlineNone = () => {\n"
1286                "};",
1287                Style);
1288   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Empty;
1289   verifyFormat("const arr = () => {\n"
1290                "  x;\n"
1291                "};",
1292                Style);
1293   verifyFormat("const arrInlineEmpty = () => {};", Style);
1294   Style.AllowShortLambdasOnASingleLine = FormatStyle::SLS_Inline;
1295   verifyFormat("const arr = () => {\n"
1296                "  x;\n"
1297                "};",
1298                Style);
1299   verifyFormat("foo(() => {});", Style);
1300   verifyFormat("const arrInlineInline = () => {};", Style);
1301 }
1302 
1303 TEST_F(FormatTestJS, ReturnStatements) {
1304   verifyFormat("function() {\n"
1305                "  return [hello, world];\n"
1306                "}");
1307 }
1308 
1309 TEST_F(FormatTestJS, ForLoops) {
1310   verifyFormat("for (var i in [2, 3]) {\n"
1311                "}");
1312   verifyFormat("for (var i of [2, 3]) {\n"
1313                "}");
1314   verifyFormat("for (let {a, b} of x) {\n"
1315                "}");
1316   verifyFormat("for (let {a, b} of [x]) {\n"
1317                "}");
1318   verifyFormat("for (let [a, b] of [x]) {\n"
1319                "}");
1320   verifyFormat("for (let {a, b} in x) {\n"
1321                "}");
1322 }
1323 
1324 TEST_F(FormatTestJS, WrapRespectsAutomaticSemicolonInsertion) {
1325   // The following statements must not wrap, as otherwise the program meaning
1326   // would change due to automatic semicolon insertion.
1327   // See http://www.ecma-international.org/ecma-262/5.1/#sec-7.9.1.
1328   verifyFormat("return aaaaa;", getGoogleJSStyleWithColumns(10));
1329   verifyFormat("yield aaaaa;", getGoogleJSStyleWithColumns(10));
1330   verifyFormat("return /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
1331   verifyFormat("continue aaaaa;", getGoogleJSStyleWithColumns(10));
1332   verifyFormat("continue /* hello! */ aaaaa;", getGoogleJSStyleWithColumns(10));
1333   verifyFormat("break aaaaa;", getGoogleJSStyleWithColumns(10));
1334   verifyFormat("throw aaaaa;", getGoogleJSStyleWithColumns(10));
1335   verifyFormat("aaaaaaaaa++;", getGoogleJSStyleWithColumns(10));
1336   verifyFormat("aaaaaaaaa--;", getGoogleJSStyleWithColumns(10));
1337   verifyFormat("return [\n"
1338                "  aaa\n"
1339                "];",
1340                getGoogleJSStyleWithColumns(12));
1341   verifyFormat("class X {\n"
1342                "  readonly ratherLongField =\n"
1343                "      1;\n"
1344                "}",
1345                "class X {\n"
1346                "  readonly ratherLongField = 1;\n"
1347                "}",
1348                getGoogleJSStyleWithColumns(20));
1349   verifyFormat("const x = (5 + 9)\n"
1350                "const y = 3\n",
1351                "const x = (   5 +    9)\n"
1352                "const y = 3\n");
1353   // Ideally the foo() bit should be indented relative to the async function().
1354   verifyFormat("async function\n"
1355                "foo() {}",
1356                getGoogleJSStyleWithColumns(10));
1357   verifyFormat("await theReckoning;", getGoogleJSStyleWithColumns(10));
1358   verifyFormat("some['a']['b']", getGoogleJSStyleWithColumns(10));
1359   verifyFormat("x = (a['a']\n"
1360                "      ['b']);",
1361                getGoogleJSStyleWithColumns(10));
1362   verifyFormat("function f() {\n"
1363                "  return foo.bar(\n"
1364                "      (param): param is {\n"
1365                "        a: SomeType\n"
1366                "      }&ABC => 1)\n"
1367                "}",
1368                getGoogleJSStyleWithColumns(25));
1369 }
1370 
1371 TEST_F(FormatTestJS, AddsIsTheDictKeyOnNewline) {
1372   // Do not confuse is, the dict key with is, the type matcher. Put is, the dict
1373   // key, on a newline.
1374   verifyFormat("Polymer({\n"
1375                "  is: '',  //\n"
1376                "  rest: 1\n"
1377                "});",
1378                getGoogleJSStyleWithColumns(20));
1379 }
1380 
1381 TEST_F(FormatTestJS, AutomaticSemicolonInsertionHeuristic) {
1382   verifyFormat("a\n"
1383                "b;",
1384                " a \n"
1385                " b ;");
1386   verifyFormat("a()\n"
1387                "b;",
1388                " a ()\n"
1389                " b ;");
1390   verifyFormat("a[b]\n"
1391                "c;",
1392                "a [b]\n"
1393                "c ;");
1394   verifyFormat("1\n"
1395                "a;",
1396                "1 \n"
1397                "a ;");
1398   verifyFormat("a\n"
1399                "1;",
1400                "a \n"
1401                "1 ;");
1402   verifyFormat("a\n"
1403                "'x';",
1404                "a \n"
1405                " 'x';");
1406   verifyFormat("a++\n"
1407                "b;",
1408                "a ++\n"
1409                "b ;");
1410   verifyFormat("a\n"
1411                "!b && c;",
1412                "a \n"
1413                " ! b && c;");
1414   verifyFormat("a\n"
1415                "if (1) f();",
1416                " a\n"
1417                " if (1) f();");
1418   verifyFormat("a\n"
1419                "class X {}",
1420                " a\n"
1421                " class X {}");
1422   verifyFormat("var a", "var\n"
1423                         "a");
1424   verifyFormat("x instanceof String", "x\n"
1425                                       "instanceof\n"
1426                                       "String");
1427   verifyFormat("function f(@Foo bar) {}", "function f(@Foo\n"
1428                                           "  bar) {}");
1429   verifyFormat("function f(@Foo(Param) bar) {}", "function f(@Foo(Param)\n"
1430                                                  "  bar) {}");
1431   verifyFormat("a = true\n"
1432                "return 1",
1433                "a = true\n"
1434                "  return   1");
1435   verifyFormat("a = 's'\n"
1436                "return 1",
1437                "a = 's'\n"
1438                "  return   1");
1439   verifyFormat("a = null\n"
1440                "return 1",
1441                "a = null\n"
1442                "  return   1");
1443   // Below "class Y {}" should ideally be on its own line.
1444   verifyFormat("x = {\n"
1445                "  a: 1\n"
1446                "} class Y {}",
1447                "  x  =  {a  : 1}\n"
1448                "   class  Y {  }");
1449   verifyFormat("if (x) {\n"
1450                "}\n"
1451                "return 1",
1452                "if (x) {}\n"
1453                " return   1");
1454   verifyFormat("if (x) {\n"
1455                "}\n"
1456                "class X {}",
1457                "if (x) {}\n"
1458                " class X {}");
1459 }
1460 
1461 TEST_F(FormatTestJS, ImportExportASI) {
1462   verifyFormat("import {x} from 'y'\n"
1463                "export function z() {}",
1464                "import   {x} from 'y'\n"
1465                "  export function z() {}");
1466   // Below "class Y {}" should ideally be on its own line.
1467   verifyFormat("export {x} class Y {}", "  export {x}\n"
1468                                         "  class  Y {\n}");
1469   verifyFormat("if (x) {\n"
1470                "}\n"
1471                "export class Y {}",
1472                "if ( x ) { }\n"
1473                " export class Y {}");
1474 }
1475 
1476 TEST_F(FormatTestJS, ImportExportType) {
1477   verifyFormat("import type {x, y} from 'y';\n"
1478                "import type * as x from 'y';\n"
1479                "import type x from 'y';\n"
1480                "import {x, type yu, z} from 'y';\n");
1481   verifyFormat("export type {x, y} from 'y';\n"
1482                "export {x, type yu, z} from 'y';\n"
1483                "export type {x, y};\n"
1484                "export {x, type yu, z};\n");
1485 }
1486 
1487 TEST_F(FormatTestJS, ClosureStyleCasts) {
1488   verifyFormat("var x = /** @type {foo} */ (bar);");
1489 }
1490 
1491 TEST_F(FormatTestJS, TryCatch) {
1492   verifyFormat("try {\n"
1493                "  f();\n"
1494                "} catch (e) {\n"
1495                "  g();\n"
1496                "} finally {\n"
1497                "  h();\n"
1498                "}");
1499 
1500   // But, of course, "catch" is a perfectly fine function name in JavaScript.
1501   verifyFormat("someObject.catch();");
1502   verifyFormat("someObject.new();");
1503 }
1504 
1505 TEST_F(FormatTestJS, StringLiteralConcatenation) {
1506   verifyFormat("var literal = 'hello ' +\n"
1507                "    'world';");
1508 
1509   // Long strings should be broken.
1510   verifyFormat("var literal =\n"
1511                "    'xxxxxxxx ' +\n"
1512                "    'xxxxxxxx';",
1513                "var literal = 'xxxxxxxx xxxxxxxx';",
1514                getGoogleJSStyleWithColumns(17));
1515   verifyFormat("var literal =\n"
1516                "    'xxxxxxxx ' +\n"
1517                "    'xxxxxxxx';",
1518                "var literal = 'xxxxxxxx xxxxxxxx';",
1519                getGoogleJSStyleWithColumns(18));
1520   verifyFormat("var literal =\n"
1521                "    'xxxxxxxx' +\n"
1522                "    ' xxxxxxxx';",
1523                "var literal = 'xxxxxxxx xxxxxxxx';",
1524                getGoogleJSStyleWithColumns(16));
1525   // The quotes should be correct.
1526   for (char OriginalQuote : {'\'', '"'}) {
1527     auto VerifyQuotes = [=](FormatStyle::JavaScriptQuoteStyle StyleQuote,
1528                             char TargetQuote) {
1529       auto Style = getGoogleJSStyleWithColumns(17);
1530       Style.JavaScriptQuotes = StyleQuote;
1531       std::string Target{"var literal =\n"
1532                          "    \"xxxxxxxx \" +\n"
1533                          "    \"xxxxxxxx\";"};
1534       std::string Original{"var literal = \"xxxxxxxx xxxxxxxx\";"};
1535       std::replace(Target.begin(), Target.end(), '"', TargetQuote);
1536       std::replace(Original.begin(), Original.end(), '"', OriginalQuote);
1537       verifyFormat(Target, Original, Style);
1538     };
1539     VerifyQuotes(FormatStyle::JSQS_Leave, OriginalQuote);
1540     VerifyQuotes(FormatStyle::JSQS_Single, '\'');
1541     VerifyQuotes(FormatStyle::JSQS_Double, '"');
1542   }
1543   // Parentheses should be added when necessary.
1544   verifyFormat("var literal =\n"
1545                "    ('xxxxxxxx ' +\n"
1546                "     'xxxxxx')[0];",
1547                "var literal = 'xxxxxxxx xxxxxx'[0];",
1548                getGoogleJSStyleWithColumns(18));
1549   auto Style = getGoogleJSStyleWithColumns(20);
1550   Style.SpacesInParens = FormatStyle::SIPO_Custom;
1551   Style.SpacesInParensOptions.Other = true;
1552   verifyFormat("var literal =\n"
1553                "    ( 'xxxxxxxx ' +\n"
1554                "      'xxxxxx' )[0];",
1555                "var literal = 'xxxxxxxx xxxxxx'[0];", Style);
1556   // FIXME: When the part before the string literal is shorter than the
1557   // continuation indentation, and the option AlignAfterOpenBracket is set to
1558   // AlwaysBreak which is the default for the Google style, the unbroken string
1559   // does not get to a new line while the broken string does due to the added
1560   // parentheses. The formatter does not do it in one pass.
1561   EXPECT_EQ(
1562       "x = ('xxxxxxxx ' +\n"
1563       "     'xxxxxx')[0];",
1564       format("x = 'xxxxxxxx xxxxxx'[0];", getGoogleJSStyleWithColumns(18)));
1565   verifyFormat("x =\n"
1566                "    ('xxxxxxxx ' +\n"
1567                "     'xxxxxx')[0];",
1568                getGoogleJSStyleWithColumns(18));
1569   // Breaking of template strings and regular expressions is not implemented.
1570   verifyFormat("var literal =\n"
1571                "    `xxxxxxxx xxxxxxxx`;",
1572                getGoogleJSStyleWithColumns(18));
1573   verifyFormat("var literal =\n"
1574                "    /xxxxxxxx xxxxxxxx/;",
1575                getGoogleJSStyleWithColumns(18));
1576   // There can be breaks in the code inside a template string.
1577   verifyFormat("var literal = `xxxxxx ${\n"
1578                "    xxxxxxxxxx} xxxxxx`;",
1579                "var literal = `xxxxxx ${xxxxxxxxxx} xxxxxx`;",
1580                getGoogleJSStyleWithColumns(14));
1581   verifyFormat("var literal = `xxxxxx ${\n"
1582                "    xxxxxxxxxx} xxxxxx`;",
1583                "var literal = `xxxxxx ${xxxxxxxxxx} xxxxxx`;",
1584                getGoogleJSStyleWithColumns(15));
1585   // Identifiers inside the code inside a template string should not be broken
1586   // even if the column limit is exceeded.  This following behavior is not
1587   // optimal.  The part after the closing brace which exceeds the column limit
1588   // can be put on a new line.  Change this test when it is implemented.
1589   verifyFormat("var literal = `xxxxxx ${\n"
1590                "    xxxxxxxxxxxxxxxxxxxxxx} xxxxxx`;",
1591                "var literal = `xxxxxx ${xxxxxxxxxxxxxxxxxxxxxx} xxxxxx`;",
1592                getGoogleJSStyleWithColumns(14));
1593   verifyFormat("var literal = `xxxxxx ${\n"
1594                "    xxxxxxxxxxxxxxxxxxxxxx +\n"
1595                "    xxxxxxxxxxxxxxxxxxxxxx} xxxxxx`;",
1596                "var literal = `xxxxxx ${xxxxxxxxxxxxxxxxxxxxxx + "
1597                "xxxxxxxxxxxxxxxxxxxxxx} xxxxxx`;",
1598                getGoogleJSStyleWithColumns(14));
1599 }
1600 
1601 TEST_F(FormatTestJS, RegexLiteralClassification) {
1602   // Regex literals.
1603   verifyFormat("var regex = /abc/;");
1604   verifyFormat("f(/abc/);");
1605   verifyFormat("f(abc, /abc/);");
1606   verifyFormat("some_map[/abc/];");
1607   verifyFormat("var x = a ? /abc/ : /abc/;");
1608   verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}");
1609   verifyFormat("var x = !/abc/.test(y);");
1610   verifyFormat("var x = foo()! / 10;");
1611   verifyFormat("var x = a && /abc/.test(y);");
1612   verifyFormat("var x = a || /abc/.test(y);");
1613   verifyFormat("var x = a + /abc/.search(y);");
1614   verifyFormat("/abc/.search(y);");
1615   verifyFormat("var regexs = {/abc/, /abc/};");
1616   verifyFormat("return /abc/;");
1617 
1618   // Not regex literals.
1619   verifyFormat("var a = a / 2 + b / 3;");
1620   verifyFormat("var a = a++ / 2;");
1621   // Prefix unary can operate on regex literals, not that it makes sense.
1622   verifyFormat("var a = ++/a/;");
1623 
1624   // This is a known issue, regular expressions are incorrectly detected if
1625   // directly following a closing parenthesis.
1626   verifyFormat("if (foo) / bar /.exec(baz);");
1627 }
1628 
1629 TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) {
1630   verifyFormat("var regex = /=/;");
1631   verifyFormat("var regex = /a*/;");
1632   verifyFormat("var regex = /a+/;");
1633   verifyFormat("var regex = /a?/;");
1634   verifyFormat("var regex = /.a./;");
1635   verifyFormat("var regex = /a\\*/;");
1636   verifyFormat("var regex = /^a$/;");
1637   verifyFormat("var regex = /\\/a/;");
1638   verifyFormat("var regex = /(?:x)/;");
1639   verifyFormat("var regex = /x(?=y)/;");
1640   verifyFormat("var regex = /x(?!y)/;");
1641   verifyFormat("var regex = /x|y/;");
1642   verifyFormat("var regex = /a{2}/;");
1643   verifyFormat("var regex = /a{1,3}/;");
1644 
1645   verifyFormat("var regex = /[abc]/;");
1646   verifyFormat("var regex = /[^abc]/;");
1647   verifyFormat("var regex = /[\\b]/;");
1648   verifyFormat("var regex = /[/]/;");
1649   verifyFormat("var regex = /[\\/]/;");
1650   verifyFormat("var regex = /\\[/;");
1651   verifyFormat("var regex = /\\\\[/]/;");
1652   verifyFormat("var regex = /}[\"]/;");
1653   verifyFormat("var regex = /}[/\"]/;");
1654   verifyFormat("var regex = /}[\"/]/;");
1655 
1656   verifyFormat("var regex = /\\b/;");
1657   verifyFormat("var regex = /\\B/;");
1658   verifyFormat("var regex = /\\d/;");
1659   verifyFormat("var regex = /\\D/;");
1660   verifyFormat("var regex = /\\f/;");
1661   verifyFormat("var regex = /\\n/;");
1662   verifyFormat("var regex = /\\r/;");
1663   verifyFormat("var regex = /\\s/;");
1664   verifyFormat("var regex = /\\S/;");
1665   verifyFormat("var regex = /\\t/;");
1666   verifyFormat("var regex = /\\v/;");
1667   verifyFormat("var regex = /\\w/;");
1668   verifyFormat("var regex = /\\W/;");
1669   verifyFormat("var regex = /a(a)\\1/;");
1670   verifyFormat("var regex = /\\0/;");
1671   verifyFormat("var regex = /\\\\/g;");
1672   verifyFormat("var regex = /\\a\\\\/g;");
1673   verifyFormat("var regex = /\a\\//g;");
1674   verifyFormat("var regex = /a\\//;\n"
1675                "var x = 0;");
1676   verifyFormat("var regex = /'/g;", "var regex = /'/g ;");
1677   verifyFormat("var regex = /'/g;  //'", "var regex = /'/g ; //'");
1678   verifyFormat("var regex = /\\/*/;\n"
1679                "var x = 0;",
1680                "var regex = /\\/*/;\n"
1681                "var x=0;");
1682   verifyFormat("var x = /a\\//;", "var x = /a\\//  \n;");
1683   verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16));
1684   verifyFormat("var regex =\n"
1685                "    /\"/;",
1686                getGoogleJSStyleWithColumns(15));
1687   verifyFormat("var regex =  //\n"
1688                "    /a/;");
1689   verifyFormat("var regexs = [\n"
1690                "  /d/,   //\n"
1691                "  /aa/,  //\n"
1692                "];");
1693 }
1694 
1695 TEST_F(FormatTestJS, RegexLiteralModifiers) {
1696   verifyFormat("var regex = /abc/g;");
1697   verifyFormat("var regex = /abc/i;");
1698   verifyFormat("var regex = /abc/m;");
1699   verifyFormat("var regex = /abc/y;");
1700 }
1701 
1702 TEST_F(FormatTestJS, RegexLiteralLength) {
1703   verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1704                getGoogleJSStyleWithColumns(60));
1705   verifyFormat("var regex =\n"
1706                "    /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1707                getGoogleJSStyleWithColumns(60));
1708   verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;",
1709                getGoogleJSStyleWithColumns(50));
1710 }
1711 
1712 TEST_F(FormatTestJS, RegexLiteralExamples) {
1713   verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);");
1714 }
1715 
1716 TEST_F(FormatTestJS, IgnoresMpegTS) {
1717   std::string MpegTS(200, ' ');
1718   MpegTS.replace(0, strlen("nearlyLooks  +   like +   ts + code;  "),
1719                  "nearlyLooks  +   like +   ts + code;  ");
1720   MpegTS[0] = 0x47;
1721   MpegTS[188] = 0x47;
1722   verifyFormat(MpegTS, MpegTS);
1723 }
1724 
1725 TEST_F(FormatTestJS, TypeAnnotations) {
1726   verifyFormat("var x: string;");
1727   verifyFormat("var x: {a: string; b: number;} = {};");
1728   verifyFormat("function x(): string {\n  return 'x';\n}");
1729   verifyFormat("function x(): {x: string} {\n  return {x: 'x'};\n}");
1730   verifyFormat("function x(y: string): string {\n  return 'x';\n}");
1731   verifyFormat("for (var y: string in x) {\n  x();\n}");
1732   verifyFormat("for (var y: string of x) {\n  x();\n}");
1733   verifyFormat("function x(y: {a?: number;} = {}): number {\n"
1734                "  return 12;\n"
1735                "}");
1736   verifyFormat("const x: Array<{a: number; b: string;}> = [];");
1737   verifyFormat("((a: string, b: number): string => a + b);");
1738   verifyFormat("var x: (y: number) => string;");
1739   verifyFormat("var x: P<string, (a: number) => string>;");
1740   verifyFormat("var x = {\n"
1741                "  y: function(): z {\n"
1742                "    return 1;\n"
1743                "  }\n"
1744                "};");
1745   verifyFormat("var x = {\n"
1746                "  y: function(): {a: number} {\n"
1747                "    return 1;\n"
1748                "  }\n"
1749                "};");
1750   verifyFormat("function someFunc(args: string[]):\n"
1751                "    {longReturnValue: string[]} {}",
1752                getGoogleJSStyleWithColumns(60));
1753   verifyFormat(
1754       "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n"
1755       "                    .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);");
1756   verifyFormat("const xIsALongIdent:\n"
1757                "    YJustBarelyFitsLinex[];",
1758                getGoogleJSStyleWithColumns(20));
1759   verifyFormat("const x = {\n"
1760                "  y: 1\n"
1761                "} as const;");
1762 }
1763 
1764 TEST_F(FormatTestJS, UnionIntersectionTypes) {
1765   verifyFormat("let x: A|B = A | B;");
1766   verifyFormat("let x: A&B|C = A & B;");
1767   verifyFormat("let x: Foo<A|B> = new Foo<A|B>();");
1768   verifyFormat("function(x: A|B): C&D {}");
1769   verifyFormat("function(x: A|B = A | B): C&D {}");
1770   verifyFormat("function x(path: number|string) {}");
1771   verifyFormat("function x(): string|number {}");
1772   verifyFormat("type Foo = Bar|Baz;");
1773   verifyFormat("type Foo = Bar<X>|Baz;");
1774   verifyFormat("type Foo = (Bar<X>|Baz);");
1775   verifyFormat("let x: Bar|Baz;");
1776   verifyFormat("let x: Bar<X>|Baz;");
1777   verifyFormat("let x: (Foo|Bar)[];");
1778   verifyFormat("type X = {\n"
1779                "  a: Foo|Bar;\n"
1780                "};");
1781   verifyFormat("export type X = {\n"
1782                "  a: Foo|Bar;\n"
1783                "};");
1784 }
1785 
1786 TEST_F(FormatTestJS, UnionIntersectionTypesInObjectType) {
1787   verifyFormat("let x: {x: number|null} = {x: number | null};");
1788   verifyFormat("let nested: {x: {y: number|null}};");
1789   verifyFormat("let mixed: {x: [number|null, {w: number}]};");
1790   verifyFormat("class X {\n"
1791                "  contructor(x: {\n"
1792                "    a: a|null,\n"
1793                "    b: b|null,\n"
1794                "  }) {}\n"
1795                "}");
1796 }
1797 
1798 TEST_F(FormatTestJS, ClassDeclarations) {
1799   verifyFormat("class C {\n  x: string = 12;\n}");
1800   verifyFormat("class C {\n  x(): string => 12;\n}");
1801   verifyFormat("class C {\n  ['x' + 2]: string = 12;\n}");
1802   verifyFormat("class C {\n"
1803                "  foo() {}\n"
1804                "  [bar]() {}\n"
1805                "}\n");
1806   verifyFormat("class C {\n  private x: string = 12;\n}");
1807   verifyFormat("class C {\n  private static x: string = 12;\n}");
1808   verifyFormat("class C {\n  static x(): string {\n    return 'asd';\n  }\n}");
1809   verifyFormat("class C extends P implements I {}");
1810   verifyFormat("class C extends p.P implements i.I {}");
1811   verifyFormat("x(class {\n"
1812                "  a(): A {}\n"
1813                "});");
1814   verifyFormat("class Test {\n"
1815                "  aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n"
1816                "      aaaaaaaaaaaaaaaaaaaaaa {}\n"
1817                "}");
1818   verifyFormat("foo = class Name {\n"
1819                "  constructor() {}\n"
1820                "};");
1821   verifyFormat("foo = class {\n"
1822                "  constructor() {}\n"
1823                "};");
1824   verifyFormat("class C {\n"
1825                "  x: {y: Z;} = {};\n"
1826                "  private y: {y: Z;} = {};\n"
1827                "}");
1828 
1829   // ':' is not a type declaration here.
1830   verifyFormat("class X {\n"
1831                "  subs = {\n"
1832                "    'b': {\n"
1833                "      'c': 1,\n"
1834                "    },\n"
1835                "  };\n"
1836                "}");
1837   verifyFormat("@Component({\n"
1838                "  moduleId: module.id,\n"
1839                "})\n"
1840                "class SessionListComponent implements OnDestroy, OnInit {\n"
1841                "}");
1842 }
1843 
1844 TEST_F(FormatTestJS, StrictPropInitWrap) {
1845   const FormatStyle &Style = getGoogleJSStyleWithColumns(22);
1846   verifyFormat("class X {\n"
1847                "  strictPropInitField!:\n"
1848                "      string;\n"
1849                "}",
1850                Style);
1851 }
1852 
1853 TEST_F(FormatTestJS, InterfaceDeclarations) {
1854   verifyFormat("interface I {\n"
1855                "  x: string;\n"
1856                "  enum: string[];\n"
1857                "  enum?: string[];\n"
1858                "}\n"
1859                "var y;");
1860   // Ensure that state is reset after parsing the interface.
1861   verifyFormat("interface a {}\n"
1862                "export function b() {}\n"
1863                "var x;");
1864 
1865   // Arrays of object type literals.
1866   verifyFormat("interface I {\n"
1867                "  o: {}[];\n"
1868                "}");
1869 }
1870 
1871 TEST_F(FormatTestJS, ObjectTypesInExtendsImplements) {
1872   verifyFormat("class C extends {} {}");
1873   verifyFormat("class C implements {bar: number} {}");
1874   // Somewhat odd, but probably closest to reasonable formatting?
1875   verifyFormat("class C implements {\n"
1876                "  bar: number,\n"
1877                "  baz: string,\n"
1878                "} {}");
1879   verifyFormat("class C<P extends {}> {}");
1880 }
1881 
1882 TEST_F(FormatTestJS, EnumDeclarations) {
1883   verifyFormat("enum Foo {\n"
1884                "  A = 1,\n"
1885                "  B\n"
1886                "}");
1887   verifyFormat("export /* somecomment*/ enum Foo {\n"
1888                "  A = 1,\n"
1889                "  B\n"
1890                "}");
1891   verifyFormat("enum Foo {\n"
1892                "  A = 1,  // comment\n"
1893                "  B\n"
1894                "}\n"
1895                "var x = 1;");
1896   verifyFormat("const enum Foo {\n"
1897                "  A = 1,\n"
1898                "  B\n"
1899                "}");
1900   verifyFormat("export const enum Foo {\n"
1901                "  A = 1,\n"
1902                "  B\n"
1903                "}");
1904 }
1905 
1906 TEST_F(FormatTestJS, Decorators) {
1907   verifyFormat("@A\nclass C {\n}");
1908   verifyFormat("@A({arg: 'value'})\nclass C {\n}");
1909   verifyFormat("@A\n@B\nclass C {\n}");
1910   verifyFormat("class C {\n  @A x: string;\n}");
1911   verifyFormat("class C {\n"
1912                "  @A\n"
1913                "  private x(): string {\n"
1914                "    return 'y';\n"
1915                "  }\n"
1916                "}");
1917   verifyFormat("class C {\n"
1918                "  private x(@A x: string) {}\n"
1919                "}");
1920   verifyFormat("class X {}\n"
1921                "class Y {}");
1922   verifyFormat("class X {\n"
1923                "  @property() private isReply = false;\n"
1924                "}\n");
1925 }
1926 
1927 TEST_F(FormatTestJS, TypeAliases) {
1928   verifyFormat("type X = number;\n"
1929                "class C {}");
1930   verifyFormat("type X<Y> = Z<Y>;");
1931   verifyFormat("type X = {\n"
1932                "  y: number\n"
1933                "};\n"
1934                "class C {}");
1935   verifyFormat("export type X = {\n"
1936                "  a: string,\n"
1937                "  b?: string,\n"
1938                "};\n");
1939 }
1940 
1941 TEST_F(FormatTestJS, TypeInterfaceLineWrapping) {
1942   const FormatStyle &Style = getGoogleJSStyleWithColumns(20);
1943   verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n"
1944                "    string;\n",
1945                "type LongTypeIsReallyUnreasonablyLong = string;\n", Style);
1946   verifyFormat("interface AbstractStrategyFactoryProvider {\n"
1947                "  a: number\n"
1948                "}\n",
1949                "interface AbstractStrategyFactoryProvider { a: number }\n",
1950                Style);
1951 }
1952 
1953 TEST_F(FormatTestJS, RemoveEmptyLinesInArrowFunctions) {
1954   verifyFormat("x = () => {\n"
1955                "  foo();\n"
1956                "  bar();\n"
1957                "};\n",
1958                "x = () => {\n"
1959                "\n"
1960                "  foo();\n"
1961                "  bar();\n"
1962                "\n"
1963                "};\n");
1964 }
1965 
1966 TEST_F(FormatTestJS, Modules) {
1967   verifyFormat("import SomeThing from 'some/module.js';");
1968   verifyFormat("import {X, Y} from 'some/module.js';");
1969   verifyFormat("import a, {X, Y} from 'some/module.js';");
1970   verifyFormat("import {X, Y,} from 'some/module.js';");
1971   verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';");
1972   // Ensure Automatic Semicolon Insertion does not break on "as\n".
1973   verifyFormat("import {X as myX} from 'm';", "import {X as\n"
1974                                               " myX} from 'm';");
1975   verifyFormat("import * as lib from 'some/module.js';");
1976   verifyFormat("var x = {import: 1};\nx.import = 2;");
1977   // Ensure an import statement inside a block is at the correct level.
1978   verifyFormat("function() {\n"
1979                "  var x;\n"
1980                "  import 'some/module.js';\n"
1981                "}");
1982 
1983   verifyFormat("export function fn() {\n"
1984                "  return 'fn';\n"
1985                "}");
1986   verifyFormat("export function A() {}\n"
1987                "export default function B() {}\n"
1988                "export function C() {}");
1989   verifyFormat("export default () => {\n"
1990                "  let x = 1;\n"
1991                "  return x;\n"
1992                "}");
1993   verifyFormat("export const x = 12;");
1994   verifyFormat("export default class X {}");
1995   verifyFormat("export {X, Y} from 'some/module.js';");
1996   verifyFormat("export {X, Y,} from 'some/module.js';");
1997   verifyFormat("export {SomeVeryLongExport as X, "
1998                "SomeOtherVeryLongExport as Y} from 'some/module.js';");
1999   // export without 'from' is wrapped.
2000   verifyFormat("export let someRatherLongVariableName =\n"
2001                "    someSurprisinglyLongVariable + someOtherRatherLongVar;");
2002   // ... but not if from is just an identifier.
2003   verifyFormat("export {\n"
2004                "  from as from,\n"
2005                "  someSurprisinglyLongVariable as\n"
2006                "      from\n"
2007                "};",
2008                getGoogleJSStyleWithColumns(20));
2009   verifyFormat("export class C {\n"
2010                "  x: number;\n"
2011                "  y: string;\n"
2012                "}");
2013   verifyFormat("export class X {\n"
2014                "  y: number;\n"
2015                "}");
2016   verifyFormat("export abstract class X {\n"
2017                "  y: number;\n"
2018                "}");
2019   verifyFormat("export default class X {\n"
2020                "  y: number\n"
2021                "}");
2022   verifyFormat("export default function() {\n  return 1;\n}");
2023   verifyFormat("export var x = 12;");
2024   verifyFormat("class C {}\n"
2025                "export function f() {}\n"
2026                "var v;");
2027   verifyFormat("export var x: number = 12;");
2028   verifyFormat("export const y = {\n"
2029                "  a: 1,\n"
2030                "  b: 2\n"
2031                "};");
2032   verifyFormat("export enum Foo {\n"
2033                "  BAR,\n"
2034                "  // adsdasd\n"
2035                "  BAZ\n"
2036                "}");
2037   verifyFormat("export default [\n"
2038                "  aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n"
2039                "  bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n"
2040                "];");
2041   verifyFormat("export default [];");
2042   verifyFormat("export default () => {};");
2043   verifyFormat("export default () => {\n"
2044                "  x;\n"
2045                "  x;\n"
2046                "};");
2047   verifyFormat("export interface Foo {\n"
2048                "  foo: number;\n"
2049                "}\n"
2050                "export class Bar {\n"
2051                "  blah(): string {\n"
2052                "    return this.blah;\n"
2053                "  };\n"
2054                "}");
2055 }
2056 
2057 TEST_F(FormatTestJS, ImportWrapping) {
2058   verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying,"
2059                " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying"
2060                "} from 'some/module.js';");
2061   FormatStyle Style = getGoogleJSStyleWithColumns(80);
2062   Style.JavaScriptWrapImports = true;
2063   verifyFormat("import {\n"
2064                "  VeryLongImportsAreAnnoying,\n"
2065                "  VeryLongImportsAreAnnoying,\n"
2066                "  VeryLongImportsAreAnnoying,\n"
2067                "} from 'some/module.js';",
2068                Style);
2069   verifyFormat("import {\n"
2070                "  A,\n"
2071                "  A,\n"
2072                "} from 'some/module.js';",
2073                Style);
2074   verifyFormat("export {\n"
2075                "  A,\n"
2076                "  A,\n"
2077                "} from 'some/module.js';",
2078                Style);
2079   Style.ColumnLimit = 40;
2080   // Using this version of verifyFormat because test::messUp hides the issue.
2081   verifyFormat("import {\n"
2082                "  A,\n"
2083                "} from\n"
2084                "    'some/path/longer/than/column/limit/module.js';",
2085                " import  {  \n"
2086                "    A,  \n"
2087                "  }    from\n"
2088                "      'some/path/longer/than/column/limit/module.js'  ; ",
2089                Style);
2090 }
2091 
2092 TEST_F(FormatTestJS, TemplateStrings) {
2093   // Keeps any whitespace/indentation within the template string.
2094   verifyFormat("var x = `hello\n"
2095                "     ${name}\n"
2096                "  !`;",
2097                "var x    =    `hello\n"
2098                "     ${  name    }\n"
2099                "  !`;");
2100 
2101   verifyFormat("var x =\n"
2102                "    `hello ${world}` >= some();",
2103                getGoogleJSStyleWithColumns(34)); // Barely doesn't fit.
2104   verifyFormat("var x = `hello ${world}` >= some();",
2105                getGoogleJSStyleWithColumns(35)); // Barely fits.
2106   verifyFormat("var x = `hellö ${wörld}` >= söme();",
2107                getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8.
2108   verifyFormat("var x = `hello\n"
2109                "  ${world}` >=\n"
2110                "    some();",
2111                "var x =\n"
2112                "    `hello\n"
2113                "  ${world}` >= some();",
2114                getGoogleJSStyleWithColumns(21)); // Barely doesn't fit.
2115   verifyFormat("var x = `hello\n"
2116                "  ${world}` >= some();",
2117                "var x =\n"
2118                "    `hello\n"
2119                "  ${world}` >= some();",
2120                getGoogleJSStyleWithColumns(22)); // Barely fits.
2121 
2122   verifyFormat("var x =\n"
2123                "    `h`;",
2124                getGoogleJSStyleWithColumns(11));
2125   verifyFormat("var x =\n    `multi\n  line`;", "var x = `multi\n  line`;",
2126                getGoogleJSStyleWithColumns(13));
2127   verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n"
2128                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);");
2129   // Repro for an obscure width-miscounting issue with template strings.
2130   verifyFormat(
2131       "someLongVariable =\n"
2132       "    "
2133       "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;",
2134       "someLongVariable = "
2135       "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;");
2136 
2137   // Make sure template strings get a proper ColumnWidth assigned, even if they
2138   // are first token in line.
2139   verifyFormat("var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n"
2140                "    `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;");
2141 
2142   // Two template strings.
2143   verifyFormat("var x = `hello` == `hello`;");
2144 
2145   // Comments in template strings.
2146   verifyFormat("var x = `//a`;\n"
2147                "var y;",
2148                "var x =\n `//a`;\n"
2149                "var y  ;");
2150   verifyFormat("var x = `/*a`;\n"
2151                "var y;",
2152                "var x =\n `/*a`;\n"
2153                "var y;");
2154   // Unterminated string literals in a template string.
2155   verifyFormat("var x = `'`;  // comment with matching quote '\n"
2156                "var y;");
2157   verifyFormat("var x = `\"`;  // comment with matching quote \"\n"
2158                "var y;");
2159   verifyFormat("it(`'aaaaaaaaaaaaaaa   `, aaaaaaaaa);",
2160                "it(`'aaaaaaaaaaaaaaa   `,   aaaaaaaaa) ;",
2161                getGoogleJSStyleWithColumns(40));
2162   // Backticks in a comment - not a template string.
2163   verifyFormat("var x = 1  // `/*a`;\n"
2164                "    ;",
2165                "var x =\n 1  // `/*a`;\n"
2166                "    ;");
2167   verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */");
2168   // Comment spans multiple template strings.
2169   verifyFormat("var x = `/*a`;\n"
2170                "var y = ` */ `;",
2171                "var x =\n `/*a`;\n"
2172                "var y =\n ` */ `;");
2173   // Escaped backtick.
2174   verifyFormat("var x = ` \\` a`;\n"
2175                "var y;",
2176                "var x = ` \\` a`;\n"
2177                "var y;");
2178   // Escaped dollar.
2179   verifyFormat("var x = ` \\${foo}`;\n");
2180 
2181   // The token stream can contain two string_literals in sequence, but that
2182   // doesn't mean that they are implicitly concatenated in JavaScript.
2183   verifyFormat("var f = `aaaa ${a ? 'a' : 'b'}`;");
2184 
2185   // Ensure that scopes are appropriately set around evaluated expressions in
2186   // template strings.
2187   verifyFormat("var f = `aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa\n"
2188                "         aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`;",
2189                "var f = `aaaaaaaaaaaaa:${aaaaaaa.  aaaaa} aaaaaaaa\n"
2190                "         aaaaaaaaaaaaa:${  aaaaaaa. aaaaa} aaaaaaaa`;");
2191   verifyFormat("var x = someFunction(`${})`)  //\n"
2192                "            .oooooooooooooooooon();");
2193   verifyFormat("var x = someFunction(`${aaaa}${\n"
2194                "    aaaaa(  //\n"
2195                "        aaaaa)})`);");
2196 }
2197 
2198 TEST_F(FormatTestJS, TemplateStringMultiLineExpression) {
2199   verifyFormat("var f = `aaaaaaaaaaaaaaaaaa: ${\n"
2200                "    aaaaa +  //\n"
2201                "    bbbb}`;",
2202                "var f = `aaaaaaaaaaaaaaaaaa: ${aaaaa +  //\n"
2203                "                               bbbb}`;");
2204   verifyFormat("var f = `\n"
2205                "  aaaaaaaaaaaaaaaaaa: ${\n"
2206                "    aaaaa +  //\n"
2207                "    bbbb}`;",
2208                "var f  =  `\n"
2209                "  aaaaaaaaaaaaaaaaaa: ${   aaaaa  +  //\n"
2210                "                        bbbb }`;");
2211   verifyFormat("var f = `\n"
2212                "  aaaaaaaaaaaaaaaaaa: ${\n"
2213                "    someFunction(\n"
2214                "        aaaaa +  //\n"
2215                "        bbbb)}`;",
2216                "var f  =  `\n"
2217                "  aaaaaaaaaaaaaaaaaa: ${someFunction (\n"
2218                "                            aaaaa  +   //\n"
2219                "                            bbbb)}`;");
2220 
2221   // It might be preferable to wrap before "someFunction".
2222   verifyFormat("var f = `\n"
2223                "  aaaaaaaaaaaaaaaaaa: ${someFunction({\n"
2224                "  aaaa: aaaaa,\n"
2225                "  bbbb: bbbbb,\n"
2226                "})}`;",
2227                "var f  =  `\n"
2228                "  aaaaaaaaaaaaaaaaaa: ${someFunction ({\n"
2229                "                          aaaa:  aaaaa,\n"
2230                "                          bbbb:  bbbbb,\n"
2231                "                        })}`;");
2232 }
2233 
2234 TEST_F(FormatTestJS, TemplateStringASI) {
2235   verifyFormat("var x = `hello${world}`;", "var x = `hello${\n"
2236                                            "    world\n"
2237                                            "}`;");
2238 }
2239 
2240 TEST_F(FormatTestJS, NestedTemplateStrings) {
2241   verifyFormat(
2242       "var x = `<ul>${xs.map(x => `<li>${x}</li>`).join('\\n')}</ul>`;");
2243   verifyFormat("var x = `he${({text: 'll'}.text)}o`;");
2244 
2245   // Crashed at some point.
2246   verifyFormat("}");
2247   verifyFormat("`");
2248   // FIXME: still crashing?
2249   // verifyFormat("`\\");
2250 }
2251 
2252 TEST_F(FormatTestJS, TaggedTemplateStrings) {
2253   verifyFormat("var x = html`<ul>`;");
2254   verifyFormat("yield `hello`;");
2255   verifyFormat("var f = {\n"
2256                "  param: longTagName`This is a ${\n"
2257                "                    'really'} long line`\n"
2258                "};",
2259                "var f = {param: longTagName`This is a ${'really'} long line`};",
2260                getGoogleJSStyleWithColumns(40));
2261 }
2262 
2263 TEST_F(FormatTestJS, CastSyntax) {
2264   verifyFormat("var x = <type>foo;");
2265   verifyFormat("var x = foo as type;");
2266   verifyFormat("let x = (a + b) as\n"
2267                "    LongTypeIsLong;",
2268                getGoogleJSStyleWithColumns(20));
2269   verifyFormat("foo = <Bar[]>[\n"
2270                "  1,  //\n"
2271                "  2\n"
2272                "];");
2273   verifyFormat("var x = [{x: 1} as type];");
2274   verifyFormat("x = x as [a, b];");
2275   verifyFormat("x = x as {a: string};");
2276   verifyFormat("x = x as (string);");
2277   verifyFormat("x = x! as (string);");
2278   verifyFormat("x = y! in z;");
2279   verifyFormat("var x = something.someFunction() as\n"
2280                "    something;",
2281                getGoogleJSStyleWithColumns(40));
2282 }
2283 
2284 TEST_F(FormatTestJS, TypeArguments) {
2285   verifyFormat("class X<Y> {}");
2286   verifyFormat("new X<Y>();");
2287   verifyFormat("foo<Y>(a);");
2288   verifyFormat("var x: X<Y>[];");
2289   verifyFormat("class C extends D<E> implements F<G>, H<I> {}");
2290   verifyFormat("function f(a: List<any> = null) {}");
2291   verifyFormat("function f(): List<any> {}");
2292   verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n"
2293                "    bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}");
2294   verifyFormat("function aaaaaaaaaa(\n"
2295                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n"
2296                "    aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n"
2297                "    aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}");
2298 }
2299 
2300 TEST_F(FormatTestJS, UserDefinedTypeGuards) {
2301   verifyFormat(
2302       "function foo(check: Object):\n"
2303       "    check is {foo: string, bar: string, baz: string, foobar: string} {\n"
2304       "  return 'bar' in check;\n"
2305       "}\n");
2306 }
2307 
2308 TEST_F(FormatTestJS, OptionalTypes) {
2309   verifyFormat("function x(a?: b, c?, d?) {}");
2310   verifyFormat("class X {\n"
2311                "  y?: z;\n"
2312                "  z?;\n"
2313                "}");
2314   verifyFormat("interface X {\n"
2315                "  y?(): z;\n"
2316                "}");
2317   verifyFormat("constructor({aa}: {\n"
2318                "  aa?: string,\n"
2319                "  aaaaaaaa?: string,\n"
2320                "  aaaaaaaaaaaaaaa?: boolean,\n"
2321                "  aaaaaa?: List<string>\n"
2322                "}) {}");
2323   verifyFormat("type X = [y?];");
2324 }
2325 
2326 TEST_F(FormatTestJS, IndexSignature) {
2327   verifyFormat("var x: {[k: string]: v};");
2328 }
2329 
2330 TEST_F(FormatTestJS, WrapAfterParen) {
2331   verifyFormat("xxxxxxxxxxx(\n"
2332                "    aaa, aaa);",
2333                getGoogleJSStyleWithColumns(20));
2334   verifyFormat("xxxxxxxxxxx(\n"
2335                "    aaa, aaa, aaa,\n"
2336                "    aaa, aaa, aaa);",
2337                getGoogleJSStyleWithColumns(20));
2338   verifyFormat("xxxxxxxxxxx(\n"
2339                "    aaaaaaaaaaaaaaaaaaaaaaaa,\n"
2340                "    function(x) {\n"
2341                "      y();  //\n"
2342                "    });",
2343                getGoogleJSStyleWithColumns(40));
2344   verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n"
2345                "       bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}");
2346 }
2347 
2348 TEST_F(FormatTestJS, JSDocAnnotations) {
2349   verifyFormat("/**\n"
2350                " * @exports {this.is.a.long.path.to.a.Type}\n"
2351                " */",
2352                "/**\n"
2353                " * @exports {this.is.a.long.path.to.a.Type}\n"
2354                " */",
2355                getGoogleJSStyleWithColumns(20));
2356   verifyFormat("/**\n"
2357                " * @mods {this.is.a.long.path.to.a.Type}\n"
2358                " */",
2359                "/**\n"
2360                " * @mods {this.is.a.long.path.to.a.Type}\n"
2361                " */",
2362                getGoogleJSStyleWithColumns(20));
2363   verifyFormat("/**\n"
2364                " * @mods {this.is.a.long.path.to.a.Type}\n"
2365                " */",
2366                "/**\n"
2367                " * @mods {this.is.a.long.path.to.a.Type}\n"
2368                " */",
2369                getGoogleJSStyleWithColumns(20));
2370   verifyFormat("/**\n"
2371                " * @param {canWrap\n"
2372                " *     onSpace}\n"
2373                " */",
2374                "/**\n"
2375                " * @param {canWrap onSpace}\n"
2376                " */",
2377                getGoogleJSStyleWithColumns(20));
2378   // make sure clang-format doesn't break before *any* '{'
2379   verifyFormat("/**\n"
2380                " * @lala {lala {lalala\n"
2381                " */\n",
2382                "/**\n"
2383                " * @lala {lala {lalala\n"
2384                " */\n",
2385                getGoogleJSStyleWithColumns(20));
2386   // cases where '{' is around the column limit
2387   for (int ColumnLimit = 6; ColumnLimit < 13; ++ColumnLimit) {
2388     verifyFormat("/**\n"
2389                  " * @param {type}\n"
2390                  " */",
2391                  "/**\n"
2392                  " * @param {type}\n"
2393                  " */",
2394                  getGoogleJSStyleWithColumns(ColumnLimit));
2395   }
2396   // don't break before @tags
2397   verifyFormat("/**\n"
2398                " * This\n"
2399                " * tag @param\n"
2400                " * stays.\n"
2401                " */",
2402                "/**\n"
2403                " * This tag @param stays.\n"
2404                " */",
2405                getGoogleJSStyleWithColumns(13));
2406   verifyFormat("/**\n"
2407                " * @see http://very/very/long/url/is/long\n"
2408                " */",
2409                "/**\n"
2410                " * @see http://very/very/long/url/is/long\n"
2411                " */",
2412                getGoogleJSStyleWithColumns(20));
2413   verifyFormat("/**\n"
2414                " * @param This is a\n"
2415                " *     long comment\n"
2416                " *     but no type\n"
2417                " */",
2418                "/**\n"
2419                " * @param This is a long comment but no type\n"
2420                " */",
2421                getGoogleJSStyleWithColumns(20));
2422   // Break and reindent @param line and reflow unrelated lines.
2423   EXPECT_EQ("{\n"
2424             "  /**\n"
2425             "   * long long long\n"
2426             "   * long\n"
2427             "   * @param {this.is.a.long.path.to.a.Type}\n"
2428             "   *     a\n"
2429             "   * long long long\n"
2430             "   * long long\n"
2431             "   */\n"
2432             "  function f(a) {}\n"
2433             "}",
2434             format("{\n"
2435                    "/**\n"
2436                    " * long long long long\n"
2437                    " * @param {this.is.a.long.path.to.a.Type} a\n"
2438                    " * long long long long\n"
2439                    " * long\n"
2440                    " */\n"
2441                    "  function f(a) {}\n"
2442                    "}",
2443                    getGoogleJSStyleWithColumns(20)));
2444 }
2445 
2446 TEST_F(FormatTestJS, TslintComments) {
2447   // tslint uses pragma comments that must be on their own line.
2448   verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. "
2449                "Comment that needs\n"
2450                "// wrapping. Trailing line.\n"
2451                "// tslint:disable-next-line:must-be-on-own-line",
2452                "// Comment that needs wrapping. Comment that needs wrapping. "
2453                "Comment that needs wrapping.\n"
2454                "// Trailing line.\n"
2455                "// tslint:disable-next-line:must-be-on-own-line");
2456 }
2457 
2458 TEST_F(FormatTestJS, TscComments) {
2459   // As above, @ts-ignore and @ts-check comments must be on their own line.
2460   verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. "
2461                "Comment that needs\n"
2462                "// wrapping. Trailing line.\n"
2463                "// @ts-ignore",
2464                "// Comment that needs wrapping. Comment that needs wrapping. "
2465                "Comment that needs wrapping.\n"
2466                "// Trailing line.\n"
2467                "// @ts-ignore");
2468   verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. "
2469                "Comment that needs\n"
2470                "// wrapping. Trailing line.\n"
2471                "// @ts-check",
2472                "// Comment that needs wrapping. Comment that needs wrapping. "
2473                "Comment that needs wrapping.\n"
2474                "// Trailing line.\n"
2475                "// @ts-check");
2476 }
2477 
2478 TEST_F(FormatTestJS, RequoteStringsSingle) {
2479   verifyFormat("var x = 'foo';", "var x = \"foo\";");
2480   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";");
2481   verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";");
2482   verifyFormat("var x =\n"
2483                "    'foo\\'';",
2484                // Code below is 15 chars wide, doesn't fit into the line with
2485                // the \ escape added.
2486                "var x = \"foo'\";", getGoogleJSStyleWithColumns(15));
2487   // Removes no-longer needed \ escape from ".
2488   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";");
2489   // Code below fits into 15 chars *after* removing the \ escape.
2490   verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";",
2491                getGoogleJSStyleWithColumns(15));
2492   verifyFormat("// clang-format off\n"
2493                "let x = \"double\";\n"
2494                "// clang-format on\n"
2495                "let x = 'single';\n",
2496                "// clang-format off\n"
2497                "let x = \"double\";\n"
2498                "// clang-format on\n"
2499                "let x = \"single\";\n");
2500 }
2501 
2502 TEST_F(FormatTestJS, RequoteAndIndent) {
2503   verifyFormat("let x = someVeryLongFunctionThatGoesOnAndOn(\n"
2504                "    'double quoted string that needs wrapping');",
2505                "let x = someVeryLongFunctionThatGoesOnAndOn("
2506                "\"double quoted string that needs wrapping\");");
2507 
2508   verifyFormat("let x =\n"
2509                "    'foo\\'oo';\n"
2510                "let x =\n"
2511                "    'foo\\'oo';",
2512                "let x=\"foo'oo\";\n"
2513                "let x=\"foo'oo\";",
2514                getGoogleJSStyleWithColumns(15));
2515 }
2516 
2517 TEST_F(FormatTestJS, RequoteStringsDouble) {
2518   FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
2519   DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double;
2520   verifyFormat("var x = \"foo\";", DoubleQuotes);
2521   verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes);
2522   verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes);
2523 }
2524 
2525 TEST_F(FormatTestJS, RequoteStringsLeave) {
2526   FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript);
2527   LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave;
2528   verifyFormat("var x = \"foo\";", LeaveQuotes);
2529   verifyFormat("var x = 'foo';", LeaveQuotes);
2530 }
2531 
2532 TEST_F(FormatTestJS, SupportShebangLines) {
2533   verifyFormat("#!/usr/bin/env node\n"
2534                "var x = hello();",
2535                "#!/usr/bin/env node\n"
2536                "var x   =  hello();");
2537 }
2538 
2539 TEST_F(FormatTestJS, NonNullAssertionOperator) {
2540   verifyFormat("let x = foo!.bar();\n");
2541   verifyFormat("let x = foo ? bar! : baz;\n");
2542   verifyFormat("let x = !foo;\n");
2543   verifyFormat("if (!+a) {\n}");
2544   verifyFormat("let x = foo[0]!;\n");
2545   verifyFormat("let x = (foo)!;\n");
2546   verifyFormat("let x = x(foo!);\n");
2547   verifyFormat("a.aaaaaa(a.a!).then(\n"
2548                "    x => x(x));\n",
2549                getGoogleJSStyleWithColumns(20));
2550   verifyFormat("let x = foo! - 1;\n");
2551   verifyFormat("let x = {foo: 1}!;\n");
2552   verifyFormat("let x = hello.foo()!\n"
2553                "            .foo()!\n"
2554                "            .foo()!\n"
2555                "            .foo()!;\n",
2556                getGoogleJSStyleWithColumns(20));
2557   verifyFormat("let x = namespace!;\n");
2558   verifyFormat("return !!x;\n");
2559 }
2560 
2561 TEST_F(FormatTestJS, CppKeywords) {
2562   // Make sure we don't mess stuff up because of C++ keywords.
2563   verifyFormat("return operator && (aa);");
2564   // .. or QT ones.
2565   verifyFormat("const slots: Slot[];");
2566   // use the "!" assertion operator to validate that clang-format understands
2567   // these C++ keywords aren't keywords in JS/TS.
2568   verifyFormat("auto!;");
2569   verifyFormat("char!;");
2570   verifyFormat("concept!;");
2571   verifyFormat("double!;");
2572   verifyFormat("extern!;");
2573   verifyFormat("float!;");
2574   verifyFormat("inline!;");
2575   verifyFormat("int!;");
2576   verifyFormat("long!;");
2577   verifyFormat("register!;");
2578   verifyFormat("restrict!;");
2579   verifyFormat("sizeof!;");
2580   verifyFormat("struct!;");
2581   verifyFormat("typedef!;");
2582   verifyFormat("union!;");
2583   verifyFormat("unsigned!;");
2584   verifyFormat("volatile!;");
2585   verifyFormat("_Alignas!;");
2586   verifyFormat("_Alignof!;");
2587   verifyFormat("_Atomic!;");
2588   verifyFormat("_Bool!;");
2589   verifyFormat("_Complex!;");
2590   verifyFormat("_Generic!;");
2591   verifyFormat("_Imaginary!;");
2592   verifyFormat("_Noreturn!;");
2593   verifyFormat("_Static_assert!;");
2594   verifyFormat("_Thread_local!;");
2595   verifyFormat("__func__!;");
2596   verifyFormat("__objc_yes!;");
2597   verifyFormat("__objc_no!;");
2598   verifyFormat("asm!;");
2599   verifyFormat("bool!;");
2600   verifyFormat("const_cast!;");
2601   verifyFormat("dynamic_cast!;");
2602   verifyFormat("explicit!;");
2603   verifyFormat("friend!;");
2604   verifyFormat("mutable!;");
2605   verifyFormat("operator!;");
2606   verifyFormat("reinterpret_cast!;");
2607   verifyFormat("static_cast!;");
2608   verifyFormat("template!;");
2609   verifyFormat("typename!;");
2610   verifyFormat("typeid!;");
2611   verifyFormat("using!;");
2612   verifyFormat("virtual!;");
2613   verifyFormat("wchar_t!;");
2614 
2615   // Positive tests:
2616   verifyFormat("x.type!;");
2617   verifyFormat("x.get!;");
2618   verifyFormat("x.set!;");
2619 }
2620 
2621 TEST_F(FormatTestJS, NullPropagatingOperator) {
2622   verifyFormat("let x = foo?.bar?.baz();\n");
2623   verifyFormat("let x = foo?.(foo);\n");
2624   verifyFormat("let x = foo?.['arr'];\n");
2625 }
2626 
2627 TEST_F(FormatTestJS, NullishCoalescingOperator) {
2628   verifyFormat("const val = something ?? 'some other default';\n");
2629   verifyFormat(
2630       "const val = something ?? otherDefault ??\n"
2631       "    evenMore ?? evenMore;\n",
2632       "const val = something ?? otherDefault ?? evenMore ?? evenMore;\n",
2633       getGoogleJSStyleWithColumns(40));
2634 }
2635 
2636 TEST_F(FormatTestJS, AssignmentOperators) {
2637   verifyFormat("a &&= b;\n");
2638   verifyFormat("a ||= b;\n");
2639   // NB: need to split ? ?= to avoid it being interpreted by C++ as a trigraph
2640   // for #.
2641   verifyFormat("a ?"
2642                "?= b;\n");
2643 }
2644 
2645 TEST_F(FormatTestJS, Conditional) {
2646   verifyFormat("y = x ? 1 : 2;");
2647   verifyFormat("x ? 1 : 2;");
2648   verifyFormat("class Foo {\n"
2649                "  field = true ? 1 : 2;\n"
2650                "  method(a = true ? 1 : 2) {}\n"
2651                "}");
2652 }
2653 
2654 TEST_F(FormatTestJS, ImportComments) {
2655   verifyFormat("import {x} from 'x';  // from some location",
2656                getGoogleJSStyleWithColumns(25));
2657   verifyFormat("// taze: x from 'location'", getGoogleJSStyleWithColumns(10));
2658   verifyFormat("/// <reference path=\"some/location\" />",
2659                getGoogleJSStyleWithColumns(10));
2660 }
2661 
2662 TEST_F(FormatTestJS, Exponentiation) {
2663   verifyFormat("squared = x ** 2;");
2664   verifyFormat("squared **= 2;");
2665 }
2666 
2667 TEST_F(FormatTestJS, NestedLiterals) {
2668   FormatStyle FourSpaces = getGoogleJSStyleWithColumns(15);
2669   FourSpaces.IndentWidth = 4;
2670   verifyFormat("var l = [\n"
2671                "    [\n"
2672                "        1,\n"
2673                "    ],\n"
2674                "];",
2675                FourSpaces);
2676   verifyFormat("var l = [\n"
2677                "    {\n"
2678                "        1: 1,\n"
2679                "    },\n"
2680                "];",
2681                FourSpaces);
2682   verifyFormat("someFunction(\n"
2683                "    p1,\n"
2684                "    [\n"
2685                "        1,\n"
2686                "    ],\n"
2687                ");",
2688                FourSpaces);
2689   verifyFormat("someFunction(\n"
2690                "    p1,\n"
2691                "    {\n"
2692                "        1: 1,\n"
2693                "    },\n"
2694                ");",
2695                FourSpaces);
2696   verifyFormat("var o = {\n"
2697                "    1: 1,\n"
2698                "    2: {\n"
2699                "        3: 3,\n"
2700                "    },\n"
2701                "};",
2702                FourSpaces);
2703   verifyFormat("var o = {\n"
2704                "    1: 1,\n"
2705                "    2: [\n"
2706                "        3,\n"
2707                "    ],\n"
2708                "};",
2709                FourSpaces);
2710 }
2711 
2712 TEST_F(FormatTestJS, BackslashesInComments) {
2713   verifyFormat("// hello \\\n"
2714                "if (x) foo();\n",
2715                "// hello \\\n"
2716                "     if ( x) \n"
2717                "   foo();\n");
2718   verifyFormat("/* ignore \\\n"
2719                " */\n"
2720                "if (x) foo();\n",
2721                "/* ignore \\\n"
2722                " */\n"
2723                " if (  x) foo();\n");
2724   verifyFormat("// st \\ art\\\n"
2725                "// comment"
2726                "// continue \\\n"
2727                "formatMe();\n",
2728                "// st \\ art\\\n"
2729                "// comment"
2730                "// continue \\\n"
2731                "formatMe( );\n");
2732 }
2733 
2734 TEST_F(FormatTestJS, AddsLastLinePenaltyIfEndingIsBroken) {
2735   EXPECT_EQ(
2736       "a = function() {\n"
2737       "  b = function() {\n"
2738       "    this.aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa] = aaaa.aaaaaa ?\n"
2739       "        aaaa.aaaaaa : /** @type "
2740       "{aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaaaaaaaa} */\n"
2741       "        (aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaa.aaaaaaaaaaaaaaaaa);\n"
2742       "  };\n"
2743       "};",
2744       format("a = function() {\n"
2745              "  b = function() {\n"
2746              "    this.aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa] = aaaa.aaaaaa ? "
2747              "aaaa.aaaaaa : /** @type "
2748              "{aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaaaaaaaa} */\n"
2749              "        (aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaa.aaaaaaaaaaaaaaaaa);\n"
2750              "  };\n"
2751              "};"));
2752 }
2753 
2754 TEST_F(FormatTestJS, ParameterNamingComment) {
2755   verifyFormat("callFoo(/*spaceAfterParameterNamingComment=*/ 1);");
2756 }
2757 
2758 TEST_F(FormatTestJS, ConditionalTypes) {
2759   // Formatting below is not necessarily intentional, this just ensures that
2760   // clang-format does not break the code.
2761   verifyFormat( // wrap
2762       "type UnionToIntersection<U> =\n"
2763       "    (U extends any ? (k: U) => void :\n"
2764       "                     never) extends((k: infer I) => void) ? I : never;");
2765 }
2766 
2767 TEST_F(FormatTestJS, SupportPrivateFieldsAndMethods) {
2768   verifyFormat("class Example {\n"
2769                "  pub = 1;\n"
2770                "  #priv = 2;\n"
2771                "  static pub2 = 'foo';\n"
2772                "  static #priv2 = 'bar';\n"
2773                "  method() {\n"
2774                "    this.#priv = 5;\n"
2775                "  }\n"
2776                "  static staticMethod() {\n"
2777                "    switch (this.#priv) {\n"
2778                "      case '1':\n"
2779                "        #priv = 3;\n"
2780                "        break;\n"
2781                "    }\n"
2782                "  }\n"
2783                "  #privateMethod() {\n"
2784                "    this.#privateMethod();  // infinite loop\n"
2785                "  }\n"
2786                "  static #staticPrivateMethod() {}\n");
2787 }
2788 
2789 TEST_F(FormatTestJS, DeclaredFields) {
2790   verifyFormat("class Example {\n"
2791                "  declare pub: string;\n"
2792                "  declare private priv: string;\n"
2793                "}\n");
2794 }
2795 
2796 TEST_F(FormatTestJS, NoBreakAfterAsserts) {
2797   verifyFormat(
2798       "interface Assertable<State extends {}> {\n"
2799       "  assert<ExportedState extends {}, DependencyState extends State = "
2800       "State>(\n"
2801       "      callback: Callback<ExportedState, DependencyState>):\n"
2802       "      asserts this is ExtendedState<DependencyState&ExportedState>;\n"
2803       "}\n",
2804       "interface Assertable<State extends {}> {\n"
2805       "  assert<ExportedState extends {}, DependencyState extends State = "
2806       "State>(callback: Callback<ExportedState, DependencyState>): asserts "
2807       "this is ExtendedState<DependencyState&ExportedState>;\n"
2808       "}\n");
2809 }
2810 
2811 TEST_F(FormatTestJS, NumericSeparators) {
2812   verifyFormat("x = 1_000_000 + 12;", "x = 1_000_000   + 12;");
2813 }
2814 
2815 TEST_F(FormatTestJS, AlignConsecutiveDeclarations) {
2816   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
2817   Style.AlignConsecutiveDeclarations.Enabled = true;
2818   verifyFormat("let    letVariable = 5;\n"
2819                "double constVariable = 10;",
2820                Style);
2821 
2822   verifyFormat("let   letVariable = 5;\n"
2823                "const constVariable = 10;",
2824                Style);
2825 
2826   verifyFormat("let          letVariable = 5;\n"
2827                "static const constVariable = 10;",
2828                Style);
2829 
2830   verifyFormat("let        letVariable = 5;\n"
2831                "static var constVariable = 10;",
2832                Style);
2833 
2834   verifyFormat("let letVariable = 5;\n"
2835                "var constVariable = 10;",
2836                Style);
2837 
2838   verifyFormat("double letVariable = 5;\n"
2839                "var    constVariable = 10;",
2840                Style);
2841 
2842   verifyFormat("const letVariable = 5;\n"
2843                "var   constVariable = 10;",
2844                Style);
2845 
2846   verifyFormat("int letVariable = 5;\n"
2847                "int constVariable = 10;",
2848                Style);
2849 }
2850 
2851 TEST_F(FormatTestJS, AlignConsecutiveAssignments) {
2852   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
2853 
2854   Style.AlignConsecutiveAssignments.Enabled = true;
2855   verifyFormat("let letVariable      = 5;\n"
2856                "double constVariable = 10;",
2857                Style);
2858 
2859   verifyFormat("let letVariable     = 5;\n"
2860                "const constVariable = 10;",
2861                Style);
2862 
2863   verifyFormat("let letVariable            = 5;\n"
2864                "static const constVariable = 10;",
2865                Style);
2866 
2867   verifyFormat("let letVariable          = 5;\n"
2868                "static var constVariable = 10;",
2869                Style);
2870 
2871   verifyFormat("let letVariable   = 5;\n"
2872                "var constVariable = 10;",
2873                Style);
2874 
2875   verifyFormat("double letVariable = 5;\n"
2876                "var constVariable  = 10;",
2877                Style);
2878 
2879   verifyFormat("const letVariable = 5;\n"
2880                "var constVariable = 10;",
2881                Style);
2882 
2883   verifyFormat("int letVariable   = 5;\n"
2884                "int constVariable = 10;",
2885                Style);
2886 }
2887 
2888 TEST_F(FormatTestJS, AlignConsecutiveAssignmentsAndDeclarations) {
2889   FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript);
2890   Style.AlignConsecutiveDeclarations.Enabled = true;
2891   Style.AlignConsecutiveAssignments.Enabled = true;
2892   verifyFormat("let    letVariable   = 5;\n"
2893                "double constVariable = 10;",
2894                Style);
2895 
2896   verifyFormat("let   letVariable   = 5;\n"
2897                "const constVariable = 10;",
2898                Style);
2899 
2900   verifyFormat("let          letVariable   = 5;\n"
2901                "static const constVariable = 10;",
2902                Style);
2903 
2904   verifyFormat("let        letVariable   = 5;\n"
2905                "static var constVariable = 10;",
2906                Style);
2907 
2908   verifyFormat("let letVariable   = 5;\n"
2909                "var constVariable = 10;",
2910                Style);
2911 
2912   verifyFormat("double letVariable   = 5;\n"
2913                "var    constVariable = 10;",
2914                Style);
2915 
2916   verifyFormat("const letVariable   = 5;\n"
2917                "var   constVariable = 10;",
2918                Style);
2919 
2920   verifyFormat("int letVariable   = 5;\n"
2921                "int constVariable = 10;",
2922                Style);
2923 }
2924 
2925 } // namespace format
2926 } // end namespace clang
2927