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