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 // String breaking is disabled for now. 1510 verifyFormat("var literal =\n" 1511 " 'xxxxxxxx xxxxxxxx';", 1512 "var literal = 'xxxxxxxx xxxxxxxx';", 1513 getGoogleJSStyleWithColumns(17)); 1514 } 1515 1516 TEST_F(FormatTestJS, RegexLiteralClassification) { 1517 // Regex literals. 1518 verifyFormat("var regex = /abc/;"); 1519 verifyFormat("f(/abc/);"); 1520 verifyFormat("f(abc, /abc/);"); 1521 verifyFormat("some_map[/abc/];"); 1522 verifyFormat("var x = a ? /abc/ : /abc/;"); 1523 verifyFormat("for (var i = 0; /abc/.test(s[i]); i++) {\n}"); 1524 verifyFormat("var x = !/abc/.test(y);"); 1525 verifyFormat("var x = foo()! / 10;"); 1526 verifyFormat("var x = a && /abc/.test(y);"); 1527 verifyFormat("var x = a || /abc/.test(y);"); 1528 verifyFormat("var x = a + /abc/.search(y);"); 1529 verifyFormat("/abc/.search(y);"); 1530 verifyFormat("var regexs = {/abc/, /abc/};"); 1531 verifyFormat("return /abc/;"); 1532 1533 // Not regex literals. 1534 verifyFormat("var a = a / 2 + b / 3;"); 1535 verifyFormat("var a = a++ / 2;"); 1536 // Prefix unary can operate on regex literals, not that it makes sense. 1537 verifyFormat("var a = ++/a/;"); 1538 1539 // This is a known issue, regular expressions are incorrectly detected if 1540 // directly following a closing parenthesis. 1541 verifyFormat("if (foo) / bar /.exec(baz);"); 1542 } 1543 1544 TEST_F(FormatTestJS, RegexLiteralSpecialCharacters) { 1545 verifyFormat("var regex = /=/;"); 1546 verifyFormat("var regex = /a*/;"); 1547 verifyFormat("var regex = /a+/;"); 1548 verifyFormat("var regex = /a?/;"); 1549 verifyFormat("var regex = /.a./;"); 1550 verifyFormat("var regex = /a\\*/;"); 1551 verifyFormat("var regex = /^a$/;"); 1552 verifyFormat("var regex = /\\/a/;"); 1553 verifyFormat("var regex = /(?:x)/;"); 1554 verifyFormat("var regex = /x(?=y)/;"); 1555 verifyFormat("var regex = /x(?!y)/;"); 1556 verifyFormat("var regex = /x|y/;"); 1557 verifyFormat("var regex = /a{2}/;"); 1558 verifyFormat("var regex = /a{1,3}/;"); 1559 1560 verifyFormat("var regex = /[abc]/;"); 1561 verifyFormat("var regex = /[^abc]/;"); 1562 verifyFormat("var regex = /[\\b]/;"); 1563 verifyFormat("var regex = /[/]/;"); 1564 verifyFormat("var regex = /[\\/]/;"); 1565 verifyFormat("var regex = /\\[/;"); 1566 verifyFormat("var regex = /\\\\[/]/;"); 1567 verifyFormat("var regex = /}[\"]/;"); 1568 verifyFormat("var regex = /}[/\"]/;"); 1569 verifyFormat("var regex = /}[\"/]/;"); 1570 1571 verifyFormat("var regex = /\\b/;"); 1572 verifyFormat("var regex = /\\B/;"); 1573 verifyFormat("var regex = /\\d/;"); 1574 verifyFormat("var regex = /\\D/;"); 1575 verifyFormat("var regex = /\\f/;"); 1576 verifyFormat("var regex = /\\n/;"); 1577 verifyFormat("var regex = /\\r/;"); 1578 verifyFormat("var regex = /\\s/;"); 1579 verifyFormat("var regex = /\\S/;"); 1580 verifyFormat("var regex = /\\t/;"); 1581 verifyFormat("var regex = /\\v/;"); 1582 verifyFormat("var regex = /\\w/;"); 1583 verifyFormat("var regex = /\\W/;"); 1584 verifyFormat("var regex = /a(a)\\1/;"); 1585 verifyFormat("var regex = /\\0/;"); 1586 verifyFormat("var regex = /\\\\/g;"); 1587 verifyFormat("var regex = /\\a\\\\/g;"); 1588 verifyFormat("var regex = /\a\\//g;"); 1589 verifyFormat("var regex = /a\\//;\n" 1590 "var x = 0;"); 1591 verifyFormat("var regex = /'/g;", "var regex = /'/g ;"); 1592 verifyFormat("var regex = /'/g; //'", "var regex = /'/g ; //'"); 1593 verifyFormat("var regex = /\\/*/;\n" 1594 "var x = 0;", 1595 "var regex = /\\/*/;\n" 1596 "var x=0;"); 1597 verifyFormat("var x = /a\\//;", "var x = /a\\// \n;"); 1598 verifyFormat("var regex = /\"/;", getGoogleJSStyleWithColumns(16)); 1599 verifyFormat("var regex =\n" 1600 " /\"/;", 1601 getGoogleJSStyleWithColumns(15)); 1602 verifyFormat("var regex = //\n" 1603 " /a/;"); 1604 verifyFormat("var regexs = [\n" 1605 " /d/, //\n" 1606 " /aa/, //\n" 1607 "];"); 1608 } 1609 1610 TEST_F(FormatTestJS, RegexLiteralModifiers) { 1611 verifyFormat("var regex = /abc/g;"); 1612 verifyFormat("var regex = /abc/i;"); 1613 verifyFormat("var regex = /abc/m;"); 1614 verifyFormat("var regex = /abc/y;"); 1615 } 1616 1617 TEST_F(FormatTestJS, RegexLiteralLength) { 1618 verifyFormat("var regex = /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;", 1619 getGoogleJSStyleWithColumns(60)); 1620 verifyFormat("var regex =\n" 1621 " /aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;", 1622 getGoogleJSStyleWithColumns(60)); 1623 verifyFormat("var regex = /\\xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/;", 1624 getGoogleJSStyleWithColumns(50)); 1625 } 1626 1627 TEST_F(FormatTestJS, RegexLiteralExamples) { 1628 verifyFormat("var regex = search.match(/(?:\?|&)times=([^?&]+)/i);"); 1629 } 1630 1631 TEST_F(FormatTestJS, IgnoresMpegTS) { 1632 std::string MpegTS(200, ' '); 1633 MpegTS.replace(0, strlen("nearlyLooks + like + ts + code; "), 1634 "nearlyLooks + like + ts + code; "); 1635 MpegTS[0] = 0x47; 1636 MpegTS[188] = 0x47; 1637 verifyFormat(MpegTS, MpegTS); 1638 } 1639 1640 TEST_F(FormatTestJS, TypeAnnotations) { 1641 verifyFormat("var x: string;"); 1642 verifyFormat("var x: {a: string; b: number;} = {};"); 1643 verifyFormat("function x(): string {\n return 'x';\n}"); 1644 verifyFormat("function x(): {x: string} {\n return {x: 'x'};\n}"); 1645 verifyFormat("function x(y: string): string {\n return 'x';\n}"); 1646 verifyFormat("for (var y: string in x) {\n x();\n}"); 1647 verifyFormat("for (var y: string of x) {\n x();\n}"); 1648 verifyFormat("function x(y: {a?: number;} = {}): number {\n" 1649 " return 12;\n" 1650 "}"); 1651 verifyFormat("const x: Array<{a: number; b: string;}> = [];"); 1652 verifyFormat("((a: string, b: number): string => a + b);"); 1653 verifyFormat("var x: (y: number) => string;"); 1654 verifyFormat("var x: P<string, (a: number) => string>;"); 1655 verifyFormat("var x = {\n" 1656 " y: function(): z {\n" 1657 " return 1;\n" 1658 " }\n" 1659 "};"); 1660 verifyFormat("var x = {\n" 1661 " y: function(): {a: number} {\n" 1662 " return 1;\n" 1663 " }\n" 1664 "};"); 1665 verifyFormat("function someFunc(args: string[]):\n" 1666 " {longReturnValue: string[]} {}", 1667 getGoogleJSStyleWithColumns(60)); 1668 verifyFormat( 1669 "var someValue = (v as aaaaaaaaaaaaaaaaaaaa<T>[])\n" 1670 " .someFunction(aaaaaaaaaaaaaaaaaaaaaaaaaaaaaa);"); 1671 verifyFormat("const xIsALongIdent:\n" 1672 " YJustBarelyFitsLinex[];", 1673 getGoogleJSStyleWithColumns(20)); 1674 verifyFormat("const x = {\n" 1675 " y: 1\n" 1676 "} as const;"); 1677 } 1678 1679 TEST_F(FormatTestJS, UnionIntersectionTypes) { 1680 verifyFormat("let x: A|B = A | B;"); 1681 verifyFormat("let x: A&B|C = A & B;"); 1682 verifyFormat("let x: Foo<A|B> = new Foo<A|B>();"); 1683 verifyFormat("function(x: A|B): C&D {}"); 1684 verifyFormat("function(x: A|B = A | B): C&D {}"); 1685 verifyFormat("function x(path: number|string) {}"); 1686 verifyFormat("function x(): string|number {}"); 1687 verifyFormat("type Foo = Bar|Baz;"); 1688 verifyFormat("type Foo = Bar<X>|Baz;"); 1689 verifyFormat("type Foo = (Bar<X>|Baz);"); 1690 verifyFormat("let x: Bar|Baz;"); 1691 verifyFormat("let x: Bar<X>|Baz;"); 1692 verifyFormat("let x: (Foo|Bar)[];"); 1693 verifyFormat("type X = {\n" 1694 " a: Foo|Bar;\n" 1695 "};"); 1696 verifyFormat("export type X = {\n" 1697 " a: Foo|Bar;\n" 1698 "};"); 1699 } 1700 1701 TEST_F(FormatTestJS, UnionIntersectionTypesInObjectType) { 1702 verifyFormat("let x: {x: number|null} = {x: number | null};"); 1703 verifyFormat("let nested: {x: {y: number|null}};"); 1704 verifyFormat("let mixed: {x: [number|null, {w: number}]};"); 1705 verifyFormat("class X {\n" 1706 " contructor(x: {\n" 1707 " a: a|null,\n" 1708 " b: b|null,\n" 1709 " }) {}\n" 1710 "}"); 1711 } 1712 1713 TEST_F(FormatTestJS, ClassDeclarations) { 1714 verifyFormat("class C {\n x: string = 12;\n}"); 1715 verifyFormat("class C {\n x(): string => 12;\n}"); 1716 verifyFormat("class C {\n ['x' + 2]: string = 12;\n}"); 1717 verifyFormat("class C {\n" 1718 " foo() {}\n" 1719 " [bar]() {}\n" 1720 "}\n"); 1721 verifyFormat("class C {\n private x: string = 12;\n}"); 1722 verifyFormat("class C {\n private static x: string = 12;\n}"); 1723 verifyFormat("class C {\n static x(): string {\n return 'asd';\n }\n}"); 1724 verifyFormat("class C extends P implements I {}"); 1725 verifyFormat("class C extends p.P implements i.I {}"); 1726 verifyFormat("x(class {\n" 1727 " a(): A {}\n" 1728 "});"); 1729 verifyFormat("class Test {\n" 1730 " aaaaaaaaaaaaaaaa(aaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaaa):\n" 1731 " aaaaaaaaaaaaaaaaaaaaaa {}\n" 1732 "}"); 1733 verifyFormat("foo = class Name {\n" 1734 " constructor() {}\n" 1735 "};"); 1736 verifyFormat("foo = class {\n" 1737 " constructor() {}\n" 1738 "};"); 1739 verifyFormat("class C {\n" 1740 " x: {y: Z;} = {};\n" 1741 " private y: {y: Z;} = {};\n" 1742 "}"); 1743 1744 // ':' is not a type declaration here. 1745 verifyFormat("class X {\n" 1746 " subs = {\n" 1747 " 'b': {\n" 1748 " 'c': 1,\n" 1749 " },\n" 1750 " };\n" 1751 "}"); 1752 verifyFormat("@Component({\n" 1753 " moduleId: module.id,\n" 1754 "})\n" 1755 "class SessionListComponent implements OnDestroy, OnInit {\n" 1756 "}"); 1757 } 1758 1759 TEST_F(FormatTestJS, StrictPropInitWrap) { 1760 const FormatStyle &Style = getGoogleJSStyleWithColumns(22); 1761 verifyFormat("class X {\n" 1762 " strictPropInitField!:\n" 1763 " string;\n" 1764 "}", 1765 Style); 1766 } 1767 1768 TEST_F(FormatTestJS, InterfaceDeclarations) { 1769 verifyFormat("interface I {\n" 1770 " x: string;\n" 1771 " enum: string[];\n" 1772 " enum?: string[];\n" 1773 "}\n" 1774 "var y;"); 1775 // Ensure that state is reset after parsing the interface. 1776 verifyFormat("interface a {}\n" 1777 "export function b() {}\n" 1778 "var x;"); 1779 1780 // Arrays of object type literals. 1781 verifyFormat("interface I {\n" 1782 " o: {}[];\n" 1783 "}"); 1784 } 1785 1786 TEST_F(FormatTestJS, ObjectTypesInExtendsImplements) { 1787 verifyFormat("class C extends {} {}"); 1788 verifyFormat("class C implements {bar: number} {}"); 1789 // Somewhat odd, but probably closest to reasonable formatting? 1790 verifyFormat("class C implements {\n" 1791 " bar: number,\n" 1792 " baz: string,\n" 1793 "} {}"); 1794 verifyFormat("class C<P extends {}> {}"); 1795 } 1796 1797 TEST_F(FormatTestJS, EnumDeclarations) { 1798 verifyFormat("enum Foo {\n" 1799 " A = 1,\n" 1800 " B\n" 1801 "}"); 1802 verifyFormat("export /* somecomment*/ enum Foo {\n" 1803 " A = 1,\n" 1804 " B\n" 1805 "}"); 1806 verifyFormat("enum Foo {\n" 1807 " A = 1, // comment\n" 1808 " B\n" 1809 "}\n" 1810 "var x = 1;"); 1811 verifyFormat("const enum Foo {\n" 1812 " A = 1,\n" 1813 " B\n" 1814 "}"); 1815 verifyFormat("export const enum Foo {\n" 1816 " A = 1,\n" 1817 " B\n" 1818 "}"); 1819 } 1820 1821 TEST_F(FormatTestJS, Decorators) { 1822 verifyFormat("@A\nclass C {\n}"); 1823 verifyFormat("@A({arg: 'value'})\nclass C {\n}"); 1824 verifyFormat("@A\n@B\nclass C {\n}"); 1825 verifyFormat("class C {\n @A x: string;\n}"); 1826 verifyFormat("class C {\n" 1827 " @A\n" 1828 " private x(): string {\n" 1829 " return 'y';\n" 1830 " }\n" 1831 "}"); 1832 verifyFormat("class C {\n" 1833 " private x(@A x: string) {}\n" 1834 "}"); 1835 verifyFormat("class X {}\n" 1836 "class Y {}"); 1837 verifyFormat("class X {\n" 1838 " @property() private isReply = false;\n" 1839 "}\n"); 1840 } 1841 1842 TEST_F(FormatTestJS, TypeAliases) { 1843 verifyFormat("type X = number;\n" 1844 "class C {}"); 1845 verifyFormat("type X<Y> = Z<Y>;"); 1846 verifyFormat("type X = {\n" 1847 " y: number\n" 1848 "};\n" 1849 "class C {}"); 1850 verifyFormat("export type X = {\n" 1851 " a: string,\n" 1852 " b?: string,\n" 1853 "};\n"); 1854 } 1855 1856 TEST_F(FormatTestJS, TypeInterfaceLineWrapping) { 1857 const FormatStyle &Style = getGoogleJSStyleWithColumns(20); 1858 verifyFormat("type LongTypeIsReallyUnreasonablyLong =\n" 1859 " string;\n", 1860 "type LongTypeIsReallyUnreasonablyLong = string;\n", Style); 1861 verifyFormat("interface AbstractStrategyFactoryProvider {\n" 1862 " a: number\n" 1863 "}\n", 1864 "interface AbstractStrategyFactoryProvider { a: number }\n", 1865 Style); 1866 } 1867 1868 TEST_F(FormatTestJS, RemoveEmptyLinesInArrowFunctions) { 1869 verifyFormat("x = () => {\n" 1870 " foo();\n" 1871 " bar();\n" 1872 "};\n", 1873 "x = () => {\n" 1874 "\n" 1875 " foo();\n" 1876 " bar();\n" 1877 "\n" 1878 "};\n"); 1879 } 1880 1881 TEST_F(FormatTestJS, Modules) { 1882 verifyFormat("import SomeThing from 'some/module.js';"); 1883 verifyFormat("import {X, Y} from 'some/module.js';"); 1884 verifyFormat("import a, {X, Y} from 'some/module.js';"); 1885 verifyFormat("import {X, Y,} from 'some/module.js';"); 1886 verifyFormat("import {X as myLocalX, Y as myLocalY} from 'some/module.js';"); 1887 // Ensure Automatic Semicolon Insertion does not break on "as\n". 1888 verifyFormat("import {X as myX} from 'm';", "import {X as\n" 1889 " myX} from 'm';"); 1890 verifyFormat("import * as lib from 'some/module.js';"); 1891 verifyFormat("var x = {import: 1};\nx.import = 2;"); 1892 // Ensure an import statement inside a block is at the correct level. 1893 verifyFormat("function() {\n" 1894 " var x;\n" 1895 " import 'some/module.js';\n" 1896 "}"); 1897 1898 verifyFormat("export function fn() {\n" 1899 " return 'fn';\n" 1900 "}"); 1901 verifyFormat("export function A() {}\n" 1902 "export default function B() {}\n" 1903 "export function C() {}"); 1904 verifyFormat("export default () => {\n" 1905 " let x = 1;\n" 1906 " return x;\n" 1907 "}"); 1908 verifyFormat("export const x = 12;"); 1909 verifyFormat("export default class X {}"); 1910 verifyFormat("export {X, Y} from 'some/module.js';"); 1911 verifyFormat("export {X, Y,} from 'some/module.js';"); 1912 verifyFormat("export {SomeVeryLongExport as X, " 1913 "SomeOtherVeryLongExport as Y} from 'some/module.js';"); 1914 // export without 'from' is wrapped. 1915 verifyFormat("export let someRatherLongVariableName =\n" 1916 " someSurprisinglyLongVariable + someOtherRatherLongVar;"); 1917 // ... but not if from is just an identifier. 1918 verifyFormat("export {\n" 1919 " from as from,\n" 1920 " someSurprisinglyLongVariable as\n" 1921 " from\n" 1922 "};", 1923 getGoogleJSStyleWithColumns(20)); 1924 verifyFormat("export class C {\n" 1925 " x: number;\n" 1926 " y: string;\n" 1927 "}"); 1928 verifyFormat("export class X {\n" 1929 " y: number;\n" 1930 "}"); 1931 verifyFormat("export abstract class X {\n" 1932 " y: number;\n" 1933 "}"); 1934 verifyFormat("export default class X {\n" 1935 " y: number\n" 1936 "}"); 1937 verifyFormat("export default function() {\n return 1;\n}"); 1938 verifyFormat("export var x = 12;"); 1939 verifyFormat("class C {}\n" 1940 "export function f() {}\n" 1941 "var v;"); 1942 verifyFormat("export var x: number = 12;"); 1943 verifyFormat("export const y = {\n" 1944 " a: 1,\n" 1945 " b: 2\n" 1946 "};"); 1947 verifyFormat("export enum Foo {\n" 1948 " BAR,\n" 1949 " // adsdasd\n" 1950 " BAZ\n" 1951 "}"); 1952 verifyFormat("export default [\n" 1953 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa,\n" 1954 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\n" 1955 "];"); 1956 verifyFormat("export default [];"); 1957 verifyFormat("export default () => {};"); 1958 verifyFormat("export default () => {\n" 1959 " x;\n" 1960 " x;\n" 1961 "};"); 1962 verifyFormat("export interface Foo {\n" 1963 " foo: number;\n" 1964 "}\n" 1965 "export class Bar {\n" 1966 " blah(): string {\n" 1967 " return this.blah;\n" 1968 " };\n" 1969 "}"); 1970 } 1971 1972 TEST_F(FormatTestJS, ImportWrapping) { 1973 verifyFormat("import {VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying," 1974 " VeryLongImportsAreAnnoying, VeryLongImportsAreAnnoying" 1975 "} from 'some/module.js';"); 1976 FormatStyle Style = getGoogleJSStyleWithColumns(80); 1977 Style.JavaScriptWrapImports = true; 1978 verifyFormat("import {\n" 1979 " VeryLongImportsAreAnnoying,\n" 1980 " VeryLongImportsAreAnnoying,\n" 1981 " VeryLongImportsAreAnnoying,\n" 1982 "} from 'some/module.js';", 1983 Style); 1984 verifyFormat("import {\n" 1985 " A,\n" 1986 " A,\n" 1987 "} from 'some/module.js';", 1988 Style); 1989 verifyFormat("export {\n" 1990 " A,\n" 1991 " A,\n" 1992 "} from 'some/module.js';", 1993 Style); 1994 Style.ColumnLimit = 40; 1995 // Using this version of verifyFormat because test::messUp hides the issue. 1996 verifyFormat("import {\n" 1997 " A,\n" 1998 "} from\n" 1999 " 'some/path/longer/than/column/limit/module.js';", 2000 " import { \n" 2001 " A, \n" 2002 " } from\n" 2003 " 'some/path/longer/than/column/limit/module.js' ; ", 2004 Style); 2005 } 2006 2007 TEST_F(FormatTestJS, TemplateStrings) { 2008 // Keeps any whitespace/indentation within the template string. 2009 verifyFormat("var x = `hello\n" 2010 " ${name}\n" 2011 " !`;", 2012 "var x = `hello\n" 2013 " ${ name }\n" 2014 " !`;"); 2015 2016 verifyFormat("var x =\n" 2017 " `hello ${world}` >= some();", 2018 getGoogleJSStyleWithColumns(34)); // Barely doesn't fit. 2019 verifyFormat("var x = `hello ${world}` >= some();", 2020 getGoogleJSStyleWithColumns(35)); // Barely fits. 2021 verifyFormat("var x = `hellö ${wörld}` >= söme();", 2022 getGoogleJSStyleWithColumns(35)); // Fits due to UTF-8. 2023 verifyFormat("var x = `hello\n" 2024 " ${world}` >=\n" 2025 " some();", 2026 "var x =\n" 2027 " `hello\n" 2028 " ${world}` >= some();", 2029 getGoogleJSStyleWithColumns(21)); // Barely doesn't fit. 2030 verifyFormat("var x = `hello\n" 2031 " ${world}` >= some();", 2032 "var x =\n" 2033 " `hello\n" 2034 " ${world}` >= some();", 2035 getGoogleJSStyleWithColumns(22)); // Barely fits. 2036 2037 verifyFormat("var x =\n" 2038 " `h`;", 2039 getGoogleJSStyleWithColumns(11)); 2040 verifyFormat("var x =\n `multi\n line`;", "var x = `multi\n line`;", 2041 getGoogleJSStyleWithColumns(13)); 2042 verifyFormat("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(\n" 2043 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`);"); 2044 // Repro for an obscure width-miscounting issue with template strings. 2045 verifyFormat( 2046 "someLongVariable =\n" 2047 " " 2048 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;", 2049 "someLongVariable = " 2050 "`${logPrefix[11]}/${logPrefix[12]}/${logPrefix[13]}${logPrefix[14]}`;"); 2051 2052 // Make sure template strings get a proper ColumnWidth assigned, even if they 2053 // are first token in line. 2054 verifyFormat("var a = aaaaaaaaaaaaaaaaaaaaaaaaaaaa ||\n" 2055 " `aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa`;"); 2056 2057 // Two template strings. 2058 verifyFormat("var x = `hello` == `hello`;"); 2059 2060 // Comments in template strings. 2061 verifyFormat("var x = `//a`;\n" 2062 "var y;", 2063 "var x =\n `//a`;\n" 2064 "var y ;"); 2065 verifyFormat("var x = `/*a`;\n" 2066 "var y;", 2067 "var x =\n `/*a`;\n" 2068 "var y;"); 2069 // Unterminated string literals in a template string. 2070 verifyFormat("var x = `'`; // comment with matching quote '\n" 2071 "var y;"); 2072 verifyFormat("var x = `\"`; // comment with matching quote \"\n" 2073 "var y;"); 2074 verifyFormat("it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa);", 2075 "it(`'aaaaaaaaaaaaaaa `, aaaaaaaaa) ;", 2076 getGoogleJSStyleWithColumns(40)); 2077 // Backticks in a comment - not a template string. 2078 verifyFormat("var x = 1 // `/*a`;\n" 2079 " ;", 2080 "var x =\n 1 // `/*a`;\n" 2081 " ;"); 2082 verifyFormat("/* ` */ var x = 1; /* ` */", "/* ` */ var x\n= 1; /* ` */"); 2083 // Comment spans multiple template strings. 2084 verifyFormat("var x = `/*a`;\n" 2085 "var y = ` */ `;", 2086 "var x =\n `/*a`;\n" 2087 "var y =\n ` */ `;"); 2088 // Escaped backtick. 2089 verifyFormat("var x = ` \\` a`;\n" 2090 "var y;", 2091 "var x = ` \\` a`;\n" 2092 "var y;"); 2093 // Escaped dollar. 2094 verifyFormat("var x = ` \\${foo}`;\n"); 2095 2096 // The token stream can contain two string_literals in sequence, but that 2097 // doesn't mean that they are implicitly concatenated in JavaScript. 2098 verifyFormat("var f = `aaaa ${a ? 'a' : 'b'}`;"); 2099 2100 // Ensure that scopes are appropriately set around evaluated expressions in 2101 // template strings. 2102 verifyFormat("var f = `aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa\n" 2103 " aaaaaaaaaaaaa:${aaaaaaa.aaaaa} aaaaaaaa`;", 2104 "var f = `aaaaaaaaaaaaa:${aaaaaaa. aaaaa} aaaaaaaa\n" 2105 " aaaaaaaaaaaaa:${ aaaaaaa. aaaaa} aaaaaaaa`;"); 2106 verifyFormat("var x = someFunction(`${})`) //\n" 2107 " .oooooooooooooooooon();"); 2108 verifyFormat("var x = someFunction(`${aaaa}${\n" 2109 " aaaaa( //\n" 2110 " aaaaa)})`);"); 2111 } 2112 2113 TEST_F(FormatTestJS, TemplateStringMultiLineExpression) { 2114 verifyFormat("var f = `aaaaaaaaaaaaaaaaaa: ${\n" 2115 " aaaaa + //\n" 2116 " bbbb}`;", 2117 "var f = `aaaaaaaaaaaaaaaaaa: ${aaaaa + //\n" 2118 " bbbb}`;"); 2119 verifyFormat("var f = `\n" 2120 " aaaaaaaaaaaaaaaaaa: ${\n" 2121 " aaaaa + //\n" 2122 " bbbb}`;", 2123 "var f = `\n" 2124 " aaaaaaaaaaaaaaaaaa: ${ aaaaa + //\n" 2125 " bbbb }`;"); 2126 verifyFormat("var f = `\n" 2127 " aaaaaaaaaaaaaaaaaa: ${\n" 2128 " someFunction(\n" 2129 " aaaaa + //\n" 2130 " bbbb)}`;", 2131 "var f = `\n" 2132 " aaaaaaaaaaaaaaaaaa: ${someFunction (\n" 2133 " aaaaa + //\n" 2134 " bbbb)}`;"); 2135 2136 // It might be preferable to wrap before "someFunction". 2137 verifyFormat("var f = `\n" 2138 " aaaaaaaaaaaaaaaaaa: ${someFunction({\n" 2139 " aaaa: aaaaa,\n" 2140 " bbbb: bbbbb,\n" 2141 "})}`;", 2142 "var f = `\n" 2143 " aaaaaaaaaaaaaaaaaa: ${someFunction ({\n" 2144 " aaaa: aaaaa,\n" 2145 " bbbb: bbbbb,\n" 2146 " })}`;"); 2147 } 2148 2149 TEST_F(FormatTestJS, TemplateStringASI) { 2150 verifyFormat("var x = `hello${world}`;", "var x = `hello${\n" 2151 " world\n" 2152 "}`;"); 2153 } 2154 2155 TEST_F(FormatTestJS, NestedTemplateStrings) { 2156 verifyFormat( 2157 "var x = `<ul>${xs.map(x => `<li>${x}</li>`).join('\\n')}</ul>`;"); 2158 verifyFormat("var x = `he${({text: 'll'}.text)}o`;"); 2159 2160 // Crashed at some point. 2161 verifyFormat("}"); 2162 verifyFormat("`"); 2163 // FIXME: still crashing? 2164 // verifyFormat("`\\"); 2165 } 2166 2167 TEST_F(FormatTestJS, TaggedTemplateStrings) { 2168 verifyFormat("var x = html`<ul>`;"); 2169 verifyFormat("yield `hello`;"); 2170 verifyFormat("var f = {\n" 2171 " param: longTagName`This is a ${\n" 2172 " 'really'} long line`\n" 2173 "};", 2174 "var f = {param: longTagName`This is a ${'really'} long line`};", 2175 getGoogleJSStyleWithColumns(40)); 2176 } 2177 2178 TEST_F(FormatTestJS, CastSyntax) { 2179 verifyFormat("var x = <type>foo;"); 2180 verifyFormat("var x = foo as type;"); 2181 verifyFormat("let x = (a + b) as\n" 2182 " LongTypeIsLong;", 2183 getGoogleJSStyleWithColumns(20)); 2184 verifyFormat("foo = <Bar[]>[\n" 2185 " 1, //\n" 2186 " 2\n" 2187 "];"); 2188 verifyFormat("var x = [{x: 1} as type];"); 2189 verifyFormat("x = x as [a, b];"); 2190 verifyFormat("x = x as {a: string};"); 2191 verifyFormat("x = x as (string);"); 2192 verifyFormat("x = x! as (string);"); 2193 verifyFormat("x = y! in z;"); 2194 verifyFormat("var x = something.someFunction() as\n" 2195 " something;", 2196 getGoogleJSStyleWithColumns(40)); 2197 } 2198 2199 TEST_F(FormatTestJS, TypeArguments) { 2200 verifyFormat("class X<Y> {}"); 2201 verifyFormat("new X<Y>();"); 2202 verifyFormat("foo<Y>(a);"); 2203 verifyFormat("var x: X<Y>[];"); 2204 verifyFormat("class C extends D<E> implements F<G>, H<I> {}"); 2205 verifyFormat("function f(a: List<any> = null) {}"); 2206 verifyFormat("function f(): List<any> {}"); 2207 verifyFormat("function aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa():\n" 2208 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb {}"); 2209 verifyFormat("function aaaaaaaaaa(\n" 2210 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa,\n" 2211 " aaaaaaaaaaaaaaaa: aaaaaaaaaaaaaaaaaaa):\n" 2212 " aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa {}"); 2213 } 2214 2215 TEST_F(FormatTestJS, UserDefinedTypeGuards) { 2216 verifyFormat( 2217 "function foo(check: Object):\n" 2218 " check is {foo: string, bar: string, baz: string, foobar: string} {\n" 2219 " return 'bar' in check;\n" 2220 "}\n"); 2221 } 2222 2223 TEST_F(FormatTestJS, OptionalTypes) { 2224 verifyFormat("function x(a?: b, c?, d?) {}"); 2225 verifyFormat("class X {\n" 2226 " y?: z;\n" 2227 " z?;\n" 2228 "}"); 2229 verifyFormat("interface X {\n" 2230 " y?(): z;\n" 2231 "}"); 2232 verifyFormat("constructor({aa}: {\n" 2233 " aa?: string,\n" 2234 " aaaaaaaa?: string,\n" 2235 " aaaaaaaaaaaaaaa?: boolean,\n" 2236 " aaaaaa?: List<string>\n" 2237 "}) {}"); 2238 verifyFormat("type X = [y?];"); 2239 } 2240 2241 TEST_F(FormatTestJS, IndexSignature) { 2242 verifyFormat("var x: {[k: string]: v};"); 2243 } 2244 2245 TEST_F(FormatTestJS, WrapAfterParen) { 2246 verifyFormat("xxxxxxxxxxx(\n" 2247 " aaa, aaa);", 2248 getGoogleJSStyleWithColumns(20)); 2249 verifyFormat("xxxxxxxxxxx(\n" 2250 " aaa, aaa, aaa,\n" 2251 " aaa, aaa, aaa);", 2252 getGoogleJSStyleWithColumns(20)); 2253 verifyFormat("xxxxxxxxxxx(\n" 2254 " aaaaaaaaaaaaaaaaaaaaaaaa,\n" 2255 " function(x) {\n" 2256 " y(); //\n" 2257 " });", 2258 getGoogleJSStyleWithColumns(40)); 2259 verifyFormat("while (aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa &&\n" 2260 " bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb) {\n}"); 2261 } 2262 2263 TEST_F(FormatTestJS, JSDocAnnotations) { 2264 verifyFormat("/**\n" 2265 " * @exports {this.is.a.long.path.to.a.Type}\n" 2266 " */", 2267 "/**\n" 2268 " * @exports {this.is.a.long.path.to.a.Type}\n" 2269 " */", 2270 getGoogleJSStyleWithColumns(20)); 2271 verifyFormat("/**\n" 2272 " * @mods {this.is.a.long.path.to.a.Type}\n" 2273 " */", 2274 "/**\n" 2275 " * @mods {this.is.a.long.path.to.a.Type}\n" 2276 " */", 2277 getGoogleJSStyleWithColumns(20)); 2278 verifyFormat("/**\n" 2279 " * @mods {this.is.a.long.path.to.a.Type}\n" 2280 " */", 2281 "/**\n" 2282 " * @mods {this.is.a.long.path.to.a.Type}\n" 2283 " */", 2284 getGoogleJSStyleWithColumns(20)); 2285 verifyFormat("/**\n" 2286 " * @param {canWrap\n" 2287 " * onSpace}\n" 2288 " */", 2289 "/**\n" 2290 " * @param {canWrap onSpace}\n" 2291 " */", 2292 getGoogleJSStyleWithColumns(20)); 2293 // make sure clang-format doesn't break before *any* '{' 2294 verifyFormat("/**\n" 2295 " * @lala {lala {lalala\n" 2296 " */\n", 2297 "/**\n" 2298 " * @lala {lala {lalala\n" 2299 " */\n", 2300 getGoogleJSStyleWithColumns(20)); 2301 // cases where '{' is around the column limit 2302 for (int ColumnLimit = 6; ColumnLimit < 13; ++ColumnLimit) { 2303 verifyFormat("/**\n" 2304 " * @param {type}\n" 2305 " */", 2306 "/**\n" 2307 " * @param {type}\n" 2308 " */", 2309 getGoogleJSStyleWithColumns(ColumnLimit)); 2310 } 2311 // don't break before @tags 2312 verifyFormat("/**\n" 2313 " * This\n" 2314 " * tag @param\n" 2315 " * stays.\n" 2316 " */", 2317 "/**\n" 2318 " * This tag @param stays.\n" 2319 " */", 2320 getGoogleJSStyleWithColumns(13)); 2321 verifyFormat("/**\n" 2322 " * @see http://very/very/long/url/is/long\n" 2323 " */", 2324 "/**\n" 2325 " * @see http://very/very/long/url/is/long\n" 2326 " */", 2327 getGoogleJSStyleWithColumns(20)); 2328 verifyFormat("/**\n" 2329 " * @param This is a\n" 2330 " * long comment\n" 2331 " * but no type\n" 2332 " */", 2333 "/**\n" 2334 " * @param This is a long comment but no type\n" 2335 " */", 2336 getGoogleJSStyleWithColumns(20)); 2337 // Break and reindent @param line and reflow unrelated lines. 2338 EXPECT_EQ("{\n" 2339 " /**\n" 2340 " * long long long\n" 2341 " * long\n" 2342 " * @param {this.is.a.long.path.to.a.Type}\n" 2343 " * a\n" 2344 " * long long long\n" 2345 " * long long\n" 2346 " */\n" 2347 " function f(a) {}\n" 2348 "}", 2349 format("{\n" 2350 "/**\n" 2351 " * long long long long\n" 2352 " * @param {this.is.a.long.path.to.a.Type} a\n" 2353 " * long long long long\n" 2354 " * long\n" 2355 " */\n" 2356 " function f(a) {}\n" 2357 "}", 2358 getGoogleJSStyleWithColumns(20))); 2359 } 2360 2361 TEST_F(FormatTestJS, TslintComments) { 2362 // tslint uses pragma comments that must be on their own line. 2363 verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. " 2364 "Comment that needs\n" 2365 "// wrapping. Trailing line.\n" 2366 "// tslint:disable-next-line:must-be-on-own-line", 2367 "// Comment that needs wrapping. Comment that needs wrapping. " 2368 "Comment that needs wrapping.\n" 2369 "// Trailing line.\n" 2370 "// tslint:disable-next-line:must-be-on-own-line"); 2371 } 2372 2373 TEST_F(FormatTestJS, TscComments) { 2374 // As above, @ts-ignore and @ts-check comments must be on their own line. 2375 verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. " 2376 "Comment that needs\n" 2377 "// wrapping. Trailing line.\n" 2378 "// @ts-ignore", 2379 "// Comment that needs wrapping. Comment that needs wrapping. " 2380 "Comment that needs wrapping.\n" 2381 "// Trailing line.\n" 2382 "// @ts-ignore"); 2383 verifyFormat("// Comment that needs wrapping. Comment that needs wrapping. " 2384 "Comment that needs\n" 2385 "// wrapping. Trailing line.\n" 2386 "// @ts-check", 2387 "// Comment that needs wrapping. Comment that needs wrapping. " 2388 "Comment that needs wrapping.\n" 2389 "// Trailing line.\n" 2390 "// @ts-check"); 2391 } 2392 2393 TEST_F(FormatTestJS, RequoteStringsSingle) { 2394 verifyFormat("var x = 'foo';", "var x = \"foo\";"); 2395 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo'o'\";"); 2396 verifyFormat("var x = 'fo\\'o\\'';", "var x = \"fo\\'o'\";"); 2397 verifyFormat("var x =\n" 2398 " 'foo\\'';", 2399 // Code below is 15 chars wide, doesn't fit into the line with 2400 // the \ escape added. 2401 "var x = \"foo'\";", getGoogleJSStyleWithColumns(15)); 2402 // Removes no-longer needed \ escape from ". 2403 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";"); 2404 // Code below fits into 15 chars *after* removing the \ escape. 2405 verifyFormat("var x = 'fo\"o';", "var x = \"fo\\\"o\";", 2406 getGoogleJSStyleWithColumns(15)); 2407 verifyFormat("// clang-format off\n" 2408 "let x = \"double\";\n" 2409 "// clang-format on\n" 2410 "let x = 'single';\n", 2411 "// clang-format off\n" 2412 "let x = \"double\";\n" 2413 "// clang-format on\n" 2414 "let x = \"single\";\n"); 2415 } 2416 2417 TEST_F(FormatTestJS, RequoteAndIndent) { 2418 verifyFormat("let x = someVeryLongFunctionThatGoesOnAndOn(\n" 2419 " 'double quoted string that needs wrapping');", 2420 "let x = someVeryLongFunctionThatGoesOnAndOn(" 2421 "\"double quoted string that needs wrapping\");"); 2422 2423 verifyFormat("let x =\n" 2424 " 'foo\\'oo';\n" 2425 "let x =\n" 2426 " 'foo\\'oo';", 2427 "let x=\"foo'oo\";\n" 2428 "let x=\"foo'oo\";", 2429 getGoogleJSStyleWithColumns(15)); 2430 } 2431 2432 TEST_F(FormatTestJS, RequoteStringsDouble) { 2433 FormatStyle DoubleQuotes = getGoogleStyle(FormatStyle::LK_JavaScript); 2434 DoubleQuotes.JavaScriptQuotes = FormatStyle::JSQS_Double; 2435 verifyFormat("var x = \"foo\";", DoubleQuotes); 2436 verifyFormat("var x = \"foo\";", "var x = 'foo';", DoubleQuotes); 2437 verifyFormat("var x = \"fo'o\";", "var x = 'fo\\'o';", DoubleQuotes); 2438 } 2439 2440 TEST_F(FormatTestJS, RequoteStringsLeave) { 2441 FormatStyle LeaveQuotes = getGoogleStyle(FormatStyle::LK_JavaScript); 2442 LeaveQuotes.JavaScriptQuotes = FormatStyle::JSQS_Leave; 2443 verifyFormat("var x = \"foo\";", LeaveQuotes); 2444 verifyFormat("var x = 'foo';", LeaveQuotes); 2445 } 2446 2447 TEST_F(FormatTestJS, SupportShebangLines) { 2448 verifyFormat("#!/usr/bin/env node\n" 2449 "var x = hello();", 2450 "#!/usr/bin/env node\n" 2451 "var x = hello();"); 2452 } 2453 2454 TEST_F(FormatTestJS, NonNullAssertionOperator) { 2455 verifyFormat("let x = foo!.bar();\n"); 2456 verifyFormat("let x = foo ? bar! : baz;\n"); 2457 verifyFormat("let x = !foo;\n"); 2458 verifyFormat("if (!+a) {\n}"); 2459 verifyFormat("let x = foo[0]!;\n"); 2460 verifyFormat("let x = (foo)!;\n"); 2461 verifyFormat("let x = x(foo!);\n"); 2462 verifyFormat("a.aaaaaa(a.a!).then(\n" 2463 " x => x(x));\n", 2464 getGoogleJSStyleWithColumns(20)); 2465 verifyFormat("let x = foo! - 1;\n"); 2466 verifyFormat("let x = {foo: 1}!;\n"); 2467 verifyFormat("let x = hello.foo()!\n" 2468 " .foo()!\n" 2469 " .foo()!\n" 2470 " .foo()!;\n", 2471 getGoogleJSStyleWithColumns(20)); 2472 verifyFormat("let x = namespace!;\n"); 2473 verifyFormat("return !!x;\n"); 2474 } 2475 2476 TEST_F(FormatTestJS, CppKeywords) { 2477 // Make sure we don't mess stuff up because of C++ keywords. 2478 verifyFormat("return operator && (aa);"); 2479 // .. or QT ones. 2480 verifyFormat("const slots: Slot[];"); 2481 // use the "!" assertion operator to validate that clang-format understands 2482 // these C++ keywords aren't keywords in JS/TS. 2483 verifyFormat("auto!;"); 2484 verifyFormat("char!;"); 2485 verifyFormat("concept!;"); 2486 verifyFormat("double!;"); 2487 verifyFormat("extern!;"); 2488 verifyFormat("float!;"); 2489 verifyFormat("inline!;"); 2490 verifyFormat("int!;"); 2491 verifyFormat("long!;"); 2492 verifyFormat("register!;"); 2493 verifyFormat("restrict!;"); 2494 verifyFormat("sizeof!;"); 2495 verifyFormat("struct!;"); 2496 verifyFormat("typedef!;"); 2497 verifyFormat("union!;"); 2498 verifyFormat("unsigned!;"); 2499 verifyFormat("volatile!;"); 2500 verifyFormat("_Alignas!;"); 2501 verifyFormat("_Alignof!;"); 2502 verifyFormat("_Atomic!;"); 2503 verifyFormat("_Bool!;"); 2504 verifyFormat("_Complex!;"); 2505 verifyFormat("_Generic!;"); 2506 verifyFormat("_Imaginary!;"); 2507 verifyFormat("_Noreturn!;"); 2508 verifyFormat("_Static_assert!;"); 2509 verifyFormat("_Thread_local!;"); 2510 verifyFormat("__func__!;"); 2511 verifyFormat("__objc_yes!;"); 2512 verifyFormat("__objc_no!;"); 2513 verifyFormat("asm!;"); 2514 verifyFormat("bool!;"); 2515 verifyFormat("const_cast!;"); 2516 verifyFormat("dynamic_cast!;"); 2517 verifyFormat("explicit!;"); 2518 verifyFormat("friend!;"); 2519 verifyFormat("mutable!;"); 2520 verifyFormat("operator!;"); 2521 verifyFormat("reinterpret_cast!;"); 2522 verifyFormat("static_cast!;"); 2523 verifyFormat("template!;"); 2524 verifyFormat("typename!;"); 2525 verifyFormat("typeid!;"); 2526 verifyFormat("using!;"); 2527 verifyFormat("virtual!;"); 2528 verifyFormat("wchar_t!;"); 2529 2530 // Positive tests: 2531 verifyFormat("x.type!;"); 2532 verifyFormat("x.get!;"); 2533 verifyFormat("x.set!;"); 2534 } 2535 2536 TEST_F(FormatTestJS, NullPropagatingOperator) { 2537 verifyFormat("let x = foo?.bar?.baz();\n"); 2538 verifyFormat("let x = foo?.(foo);\n"); 2539 verifyFormat("let x = foo?.['arr'];\n"); 2540 } 2541 2542 TEST_F(FormatTestJS, NullishCoalescingOperator) { 2543 verifyFormat("const val = something ?? 'some other default';\n"); 2544 verifyFormat( 2545 "const val = something ?? otherDefault ??\n" 2546 " evenMore ?? evenMore;\n", 2547 "const val = something ?? otherDefault ?? evenMore ?? evenMore;\n", 2548 getGoogleJSStyleWithColumns(40)); 2549 } 2550 2551 TEST_F(FormatTestJS, AssignmentOperators) { 2552 verifyFormat("a &&= b;\n"); 2553 verifyFormat("a ||= b;\n"); 2554 // NB: need to split ? ?= to avoid it being interpreted by C++ as a trigraph 2555 // for #. 2556 verifyFormat("a ?" 2557 "?= b;\n"); 2558 } 2559 2560 TEST_F(FormatTestJS, Conditional) { 2561 verifyFormat("y = x ? 1 : 2;"); 2562 verifyFormat("x ? 1 : 2;"); 2563 verifyFormat("class Foo {\n" 2564 " field = true ? 1 : 2;\n" 2565 " method(a = true ? 1 : 2) {}\n" 2566 "}"); 2567 } 2568 2569 TEST_F(FormatTestJS, ImportComments) { 2570 verifyFormat("import {x} from 'x'; // from some location", 2571 getGoogleJSStyleWithColumns(25)); 2572 verifyFormat("// taze: x from 'location'", getGoogleJSStyleWithColumns(10)); 2573 verifyFormat("/// <reference path=\"some/location\" />", 2574 getGoogleJSStyleWithColumns(10)); 2575 } 2576 2577 TEST_F(FormatTestJS, Exponentiation) { 2578 verifyFormat("squared = x ** 2;"); 2579 verifyFormat("squared **= 2;"); 2580 } 2581 2582 TEST_F(FormatTestJS, NestedLiterals) { 2583 FormatStyle FourSpaces = getGoogleJSStyleWithColumns(15); 2584 FourSpaces.IndentWidth = 4; 2585 verifyFormat("var l = [\n" 2586 " [\n" 2587 " 1,\n" 2588 " ],\n" 2589 "];", 2590 FourSpaces); 2591 verifyFormat("var l = [\n" 2592 " {\n" 2593 " 1: 1,\n" 2594 " },\n" 2595 "];", 2596 FourSpaces); 2597 verifyFormat("someFunction(\n" 2598 " p1,\n" 2599 " [\n" 2600 " 1,\n" 2601 " ],\n" 2602 ");", 2603 FourSpaces); 2604 verifyFormat("someFunction(\n" 2605 " p1,\n" 2606 " {\n" 2607 " 1: 1,\n" 2608 " },\n" 2609 ");", 2610 FourSpaces); 2611 verifyFormat("var o = {\n" 2612 " 1: 1,\n" 2613 " 2: {\n" 2614 " 3: 3,\n" 2615 " },\n" 2616 "};", 2617 FourSpaces); 2618 verifyFormat("var o = {\n" 2619 " 1: 1,\n" 2620 " 2: [\n" 2621 " 3,\n" 2622 " ],\n" 2623 "};", 2624 FourSpaces); 2625 } 2626 2627 TEST_F(FormatTestJS, BackslashesInComments) { 2628 verifyFormat("// hello \\\n" 2629 "if (x) foo();\n", 2630 "// hello \\\n" 2631 " if ( x) \n" 2632 " foo();\n"); 2633 verifyFormat("/* ignore \\\n" 2634 " */\n" 2635 "if (x) foo();\n", 2636 "/* ignore \\\n" 2637 " */\n" 2638 " if ( x) foo();\n"); 2639 verifyFormat("// st \\ art\\\n" 2640 "// comment" 2641 "// continue \\\n" 2642 "formatMe();\n", 2643 "// st \\ art\\\n" 2644 "// comment" 2645 "// continue \\\n" 2646 "formatMe( );\n"); 2647 } 2648 2649 TEST_F(FormatTestJS, AddsLastLinePenaltyIfEndingIsBroken) { 2650 EXPECT_EQ( 2651 "a = function() {\n" 2652 " b = function() {\n" 2653 " this.aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa] = aaaa.aaaaaa ?\n" 2654 " aaaa.aaaaaa : /** @type " 2655 "{aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaaaaaaaa} */\n" 2656 " (aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaa.aaaaaaaaaaaaaaaaa);\n" 2657 " };\n" 2658 "};", 2659 format("a = function() {\n" 2660 " b = function() {\n" 2661 " this.aaaaaaaaaaaaaaaaaaa[aaaaaaaaaaa] = aaaa.aaaaaa ? " 2662 "aaaa.aaaaaa : /** @type " 2663 "{aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaaaaaaaa} */\n" 2664 " (aaaa.aaaa.aaaaaaaaa.aaaaaaaaaaaaa.aaaaaaaaaaaaaaaaa);\n" 2665 " };\n" 2666 "};")); 2667 } 2668 2669 TEST_F(FormatTestJS, ParameterNamingComment) { 2670 verifyFormat("callFoo(/*spaceAfterParameterNamingComment=*/ 1);"); 2671 } 2672 2673 TEST_F(FormatTestJS, ConditionalTypes) { 2674 // Formatting below is not necessarily intentional, this just ensures that 2675 // clang-format does not break the code. 2676 verifyFormat( // wrap 2677 "type UnionToIntersection<U> =\n" 2678 " (U extends any ? (k: U) => void :\n" 2679 " never) extends((k: infer I) => void) ? I : never;"); 2680 } 2681 2682 TEST_F(FormatTestJS, SupportPrivateFieldsAndMethods) { 2683 verifyFormat("class Example {\n" 2684 " pub = 1;\n" 2685 " #priv = 2;\n" 2686 " static pub2 = 'foo';\n" 2687 " static #priv2 = 'bar';\n" 2688 " method() {\n" 2689 " this.#priv = 5;\n" 2690 " }\n" 2691 " static staticMethod() {\n" 2692 " switch (this.#priv) {\n" 2693 " case '1':\n" 2694 " #priv = 3;\n" 2695 " break;\n" 2696 " }\n" 2697 " }\n" 2698 " #privateMethod() {\n" 2699 " this.#privateMethod(); // infinite loop\n" 2700 " }\n" 2701 " static #staticPrivateMethod() {}\n"); 2702 } 2703 2704 TEST_F(FormatTestJS, DeclaredFields) { 2705 verifyFormat("class Example {\n" 2706 " declare pub: string;\n" 2707 " declare private priv: string;\n" 2708 "}\n"); 2709 } 2710 2711 TEST_F(FormatTestJS, NoBreakAfterAsserts) { 2712 verifyFormat( 2713 "interface Assertable<State extends {}> {\n" 2714 " assert<ExportedState extends {}, DependencyState extends State = " 2715 "State>(\n" 2716 " callback: Callback<ExportedState, DependencyState>):\n" 2717 " asserts this is ExtendedState<DependencyState&ExportedState>;\n" 2718 "}\n", 2719 "interface Assertable<State extends {}> {\n" 2720 " assert<ExportedState extends {}, DependencyState extends State = " 2721 "State>(callback: Callback<ExportedState, DependencyState>): asserts " 2722 "this is ExtendedState<DependencyState&ExportedState>;\n" 2723 "}\n"); 2724 } 2725 2726 TEST_F(FormatTestJS, NumericSeparators) { 2727 verifyFormat("x = 1_000_000 + 12;", "x = 1_000_000 + 12;"); 2728 } 2729 2730 TEST_F(FormatTestJS, AlignConsecutiveDeclarations) { 2731 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript); 2732 Style.AlignConsecutiveDeclarations.Enabled = true; 2733 verifyFormat("let letVariable = 5;\n" 2734 "double constVariable = 10;", 2735 Style); 2736 2737 verifyFormat("let letVariable = 5;\n" 2738 "const constVariable = 10;", 2739 Style); 2740 2741 verifyFormat("let letVariable = 5;\n" 2742 "static const constVariable = 10;", 2743 Style); 2744 2745 verifyFormat("let letVariable = 5;\n" 2746 "static var constVariable = 10;", 2747 Style); 2748 2749 verifyFormat("let letVariable = 5;\n" 2750 "var constVariable = 10;", 2751 Style); 2752 2753 verifyFormat("double letVariable = 5;\n" 2754 "var constVariable = 10;", 2755 Style); 2756 2757 verifyFormat("const letVariable = 5;\n" 2758 "var constVariable = 10;", 2759 Style); 2760 2761 verifyFormat("int letVariable = 5;\n" 2762 "int constVariable = 10;", 2763 Style); 2764 } 2765 2766 TEST_F(FormatTestJS, AlignConsecutiveAssignments) { 2767 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript); 2768 2769 Style.AlignConsecutiveAssignments.Enabled = true; 2770 verifyFormat("let letVariable = 5;\n" 2771 "double constVariable = 10;", 2772 Style); 2773 2774 verifyFormat("let letVariable = 5;\n" 2775 "const constVariable = 10;", 2776 Style); 2777 2778 verifyFormat("let letVariable = 5;\n" 2779 "static const constVariable = 10;", 2780 Style); 2781 2782 verifyFormat("let letVariable = 5;\n" 2783 "static var constVariable = 10;", 2784 Style); 2785 2786 verifyFormat("let letVariable = 5;\n" 2787 "var constVariable = 10;", 2788 Style); 2789 2790 verifyFormat("double letVariable = 5;\n" 2791 "var constVariable = 10;", 2792 Style); 2793 2794 verifyFormat("const letVariable = 5;\n" 2795 "var constVariable = 10;", 2796 Style); 2797 2798 verifyFormat("int letVariable = 5;\n" 2799 "int constVariable = 10;", 2800 Style); 2801 } 2802 2803 TEST_F(FormatTestJS, AlignConsecutiveAssignmentsAndDeclarations) { 2804 FormatStyle Style = getGoogleStyle(FormatStyle::LK_JavaScript); 2805 Style.AlignConsecutiveDeclarations.Enabled = true; 2806 Style.AlignConsecutiveAssignments.Enabled = true; 2807 verifyFormat("let letVariable = 5;\n" 2808 "double constVariable = 10;", 2809 Style); 2810 2811 verifyFormat("let letVariable = 5;\n" 2812 "const constVariable = 10;", 2813 Style); 2814 2815 verifyFormat("let letVariable = 5;\n" 2816 "static const constVariable = 10;", 2817 Style); 2818 2819 verifyFormat("let letVariable = 5;\n" 2820 "static var constVariable = 10;", 2821 Style); 2822 2823 verifyFormat("let letVariable = 5;\n" 2824 "var constVariable = 10;", 2825 Style); 2826 2827 verifyFormat("double letVariable = 5;\n" 2828 "var constVariable = 10;", 2829 Style); 2830 2831 verifyFormat("const letVariable = 5;\n" 2832 "var constVariable = 10;", 2833 Style); 2834 2835 verifyFormat("int letVariable = 5;\n" 2836 "int constVariable = 10;", 2837 Style); 2838 } 2839 2840 } // namespace format 2841 } // end namespace clang 2842