1 // Clear and create directories 2 // RUN: rm -rf %t 3 // RUN: mkdir %t 4 // RUN: mkdir %t/cache 5 // RUN: mkdir %t/Inputs 6 7 // Build first header file 8 // RUN: echo "#define FIRST" >> %t/Inputs/first.h 9 // RUN: cat %s >> %t/Inputs/first.h 10 11 // Build second header file 12 // RUN: echo "#define SECOND" >> %t/Inputs/second.h 13 // RUN: cat %s >> %t/Inputs/second.h 14 15 // Test that each header can compile 16 // RUN: %clang_cc1 -fsyntax-only -x c++ -std=c++1z %t/Inputs/first.h 17 // RUN: %clang_cc1 -fsyntax-only -x c++ -std=c++1z %t/Inputs/second.h 18 19 // Build module map file 20 // RUN: echo "module FirstModule {" >> %t/Inputs/module.map 21 // RUN: echo " header \"first.h\"" >> %t/Inputs/module.map 22 // RUN: echo "}" >> %t/Inputs/module.map 23 // RUN: echo "module SecondModule {" >> %t/Inputs/module.map 24 // RUN: echo " header \"second.h\"" >> %t/Inputs/module.map 25 // RUN: echo "}" >> %t/Inputs/module.map 26 27 // Run test 28 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x c++ -I%t/Inputs -verify %s -std=c++1z 29 30 #if !defined(FIRST) && !defined(SECOND) 31 #include "first.h" 32 #include "second.h" 33 #endif 34 35 // Used for testing 36 #if defined(FIRST) 37 #define ACCESS public: 38 #elif defined(SECOND) 39 #define ACCESS private: 40 #endif 41 42 namespace AccessSpecifiers { 43 #if defined(FIRST) 44 struct S1 { 45 }; 46 #elif defined(SECOND) 47 struct S1 { 48 private: 49 }; 50 #else 51 S1 s1; 52 // [email protected]:* {{'AccessSpecifiers::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 53 // [email protected]:* {{but in 'FirstModule' found end of class}} 54 #endif 55 56 #if defined(FIRST) 57 struct S2 { 58 public: 59 }; 60 #elif defined(SECOND) 61 struct S2 { 62 protected: 63 }; 64 #else 65 S2 s2; 66 // [email protected]:* {{'AccessSpecifiers::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found protected access specifier}} 67 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 68 #endif 69 70 #define DECLS \ 71 public: \ 72 private: \ 73 protected: 74 75 #if defined(FIRST) || defined(SECOND) 76 struct Valid1 { 77 DECLS 78 }; 79 #else 80 Valid1 v1; 81 #endif 82 83 #if defined(FIRST) || defined(SECOND) 84 struct Invalid1 { 85 DECLS 86 ACCESS 87 }; 88 #else 89 Invalid1 i1; 90 // [email protected]:* {{'AccessSpecifiers::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 91 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 92 #endif 93 94 #undef DECLS 95 } // namespace AccessSpecifiers 96 97 namespace StaticAssert { 98 #if defined(FIRST) 99 struct S1 { 100 static_assert(1 == 1, "First"); 101 }; 102 #elif defined(SECOND) 103 struct S1 { 104 static_assert(1 == 1, "Second"); 105 }; 106 #else 107 S1 s1; 108 // [email protected]:* {{'StaticAssert::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found static assert with message}} 109 // [email protected]:* {{but in 'FirstModule' found static assert with different message}} 110 #endif 111 112 #if defined(FIRST) 113 struct S2 { 114 static_assert(2 == 2, "Message"); 115 }; 116 #elif defined(SECOND) 117 struct S2 { 118 static_assert(2 == 2); 119 }; 120 #else 121 S2 s2; 122 // [email protected]:* {{'StaticAssert::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found static assert with no message}} 123 // [email protected]:* {{but in 'FirstModule' found static assert with message}} 124 #endif 125 126 #if defined(FIRST) 127 struct S3 { 128 static_assert(3 == 3, "Message"); 129 }; 130 #elif defined(SECOND) 131 struct S3 { 132 static_assert(3 != 4, "Message"); 133 }; 134 #else 135 S3 s3; 136 // [email protected]:* {{'StaticAssert::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found static assert with condition}} 137 // [email protected]:* {{but in 'FirstModule' found static assert with different condition}} 138 #endif 139 140 #if defined(FIRST) 141 struct S4 { 142 static_assert(4 == 4, "Message"); 143 }; 144 #elif defined(SECOND) 145 struct S4 { 146 public: 147 }; 148 #else 149 S4 s4; 150 // [email protected]:* {{'StaticAssert::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 151 // [email protected]:* {{but in 'FirstModule' found static assert}} 152 #endif 153 154 #define DECLS \ 155 static_assert(4 == 4, "Message"); \ 156 static_assert(5 == 5); 157 158 #if defined(FIRST) || defined(SECOND) 159 struct Valid1 { 160 DECLS 161 }; 162 #else 163 Valid1 v1; 164 #endif 165 166 #if defined(FIRST) || defined(SECOND) 167 struct Invalid1 { 168 DECLS 169 ACCESS 170 }; 171 #else 172 Invalid1 i1; 173 // [email protected]:* {{'StaticAssert::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 174 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 175 #endif 176 #undef DECLS 177 } // namespace StaticAssert 178 179 namespace Field { 180 #if defined(FIRST) 181 struct S1 { 182 int x; 183 private: 184 int y; 185 }; 186 #elif defined(SECOND) 187 struct S1 { 188 int x; 189 int y; 190 }; 191 #else 192 S1 s1; 193 // [email protected]:* {{'Field::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found field}} 194 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 195 #endif 196 197 #if defined(FIRST) 198 struct S2 { 199 int x; 200 int y; 201 }; 202 #elif defined(SECOND) 203 struct S2 { 204 int y; 205 int x; 206 }; 207 #else 208 S2 s2; 209 // [email protected]:* {{'Field::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'y'}} 210 // [email protected]:* {{but in 'FirstModule' found field 'x'}} 211 #endif 212 213 #if defined(FIRST) 214 struct S3 { 215 double x; 216 }; 217 #elif defined(SECOND) 218 struct S3 { 219 int x; 220 }; 221 #else 222 S3 s3; 223 // [email protected]:* {{'Field::S3::x' from module 'FirstModule' is not present in definition of 'Field::S3' in module 'SecondModule'}} 224 // [email protected]:* {{declaration of 'x' does not match}} 225 #endif 226 227 #if defined(FIRST) 228 typedef int A; 229 struct S4 { 230 A x; 231 }; 232 233 struct S5 { 234 A x; 235 }; 236 #elif defined(SECOND) 237 typedef int B; 238 struct S4 { 239 B x; 240 }; 241 242 struct S5 { 243 int x; 244 }; 245 #else 246 S4 s4; 247 // [email protected]:* {{'Field::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'Field::B' (aka 'int')}} 248 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'Field::A' (aka 'int')}} 249 250 S5 s5; 251 // [email protected]:* {{'Field::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'int'}} 252 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'Field::A' (aka 'int')}} 253 #endif 254 255 #if defined(FIRST) 256 struct S6 { 257 unsigned x; 258 }; 259 #elif defined(SECOND) 260 struct S6 { 261 unsigned x : 1; 262 }; 263 #else 264 S6 s6; 265 // [email protected]:* {{'Field::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found bitfield 'x'}} 266 // [email protected]:* {{but in 'FirstModule' found non-bitfield 'x'}} 267 #endif 268 269 #if defined(FIRST) 270 struct S7 { 271 unsigned x : 2; 272 }; 273 #elif defined(SECOND) 274 struct S7 { 275 unsigned x : 1; 276 }; 277 #else 278 S7 s7; 279 // [email protected]:* {{'Field::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found bitfield 'x' with one width expression}} 280 // [email protected]:* {{but in 'FirstModule' found bitfield 'x' with different width expression}} 281 #endif 282 283 #if defined(FIRST) 284 struct S8 { 285 unsigned x : 2; 286 }; 287 #elif defined(SECOND) 288 struct S8 { 289 unsigned x : 1 + 1; 290 }; 291 #else 292 S8 s8; 293 // [email protected]:* {{'Field::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found bitfield 'x' with one width expression}} 294 // [email protected]:* {{but in 'FirstModule' found bitfield 'x' with different width expression}} 295 #endif 296 297 #if defined(FIRST) 298 struct S9 { 299 mutable int x; 300 }; 301 #elif defined(SECOND) 302 struct S9 { 303 int x; 304 }; 305 #else 306 S9 s9; 307 // [email protected]:* {{'Field::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found non-mutable field 'x'}} 308 // [email protected]:* {{but in 'FirstModule' found mutable field 'x'}} 309 #endif 310 311 #if defined(FIRST) 312 struct S10 { 313 unsigned x = 5; 314 }; 315 #elif defined(SECOND) 316 struct S10 { 317 unsigned x; 318 }; 319 #else 320 S10 s10; 321 // [email protected]:* {{'Field::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with no initalizer}} 322 // [email protected]:* {{but in 'FirstModule' found field 'x' with an initializer}} 323 #endif 324 325 #if defined(FIRST) 326 struct S11 { 327 unsigned x = 5; 328 }; 329 #elif defined(SECOND) 330 struct S11 { 331 unsigned x = 7; 332 }; 333 #else 334 S11 s11; 335 // [email protected]:* {{'Field::S11' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with an initializer}} 336 // [email protected]:* {{but in 'FirstModule' found field 'x' with a different initializer}} 337 #endif 338 339 #if defined(FIRST) 340 struct S12 { 341 unsigned x[5]; 342 }; 343 #elif defined(SECOND) 344 struct S12 { 345 unsigned x[7]; 346 }; 347 #else 348 S12 s12; 349 // [email protected]:* {{'Field::S12::x' from module 'FirstModule' is not present in definition of 'Field::S12' in module 'SecondModule'}} 350 // [email protected]:* {{declaration of 'x' does not match}} 351 #endif 352 353 #if defined(FIRST) 354 struct S13 { 355 unsigned x[7]; 356 }; 357 #elif defined(SECOND) 358 struct S13 { 359 double x[7]; 360 }; 361 #else 362 S13 s13; 363 // [email protected]:* {{'Field::S13::x' from module 'FirstModule' is not present in definition of 'Field::S13' in module 'SecondModule'}} 364 // [email protected]:* {{declaration of 'x' does not match}} 365 #endif 366 367 #define DECLS \ 368 int a; \ 369 int b : 3; \ 370 unsigned c : 1 + 2; \ 371 s d; \ 372 double e = 1.0; \ 373 long f[5]; 374 375 #if defined(FIRST) || defined(SECOND) 376 typedef short s; 377 #endif 378 379 #if defined(FIRST) || defined(SECOND) 380 struct Valid1 { 381 DECLS 382 }; 383 #else 384 Valid1 v1; 385 #endif 386 387 #if defined(FIRST) || defined(SECOND) 388 struct Invalid1 { 389 DECLS 390 ACCESS 391 }; 392 #else 393 Invalid1 i1; 394 // [email protected]:* {{'Field::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 395 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 396 #endif 397 #undef DECLS 398 } // namespace Field 399 400 namespace Method { 401 #if defined(FIRST) 402 struct S1 { 403 void A() {} 404 }; 405 #elif defined(SECOND) 406 struct S1 { 407 private: 408 void A() {} 409 }; 410 #else 411 S1 s1; 412 // [email protected]:* {{'Method::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 413 // [email protected]:* {{but in 'FirstModule' found method}} 414 #endif 415 416 #if defined(FIRST) 417 struct S2 { 418 void A() {} 419 void B() {} 420 }; 421 #elif defined(SECOND) 422 struct S2 { 423 void B() {} 424 void A() {} 425 }; 426 #else 427 S2 s2; 428 // [email protected]:* {{'Method::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'B'}} 429 // [email protected]:* {{but in 'FirstModule' found method 'A'}} 430 #endif 431 432 #if defined(FIRST) 433 struct S3 { 434 static void A() {} 435 void A(int) {} 436 }; 437 #elif defined(SECOND) 438 struct S3 { 439 void A(int) {} 440 static void A() {} 441 }; 442 #else 443 S3 s3; 444 // [email protected]:* {{'Method::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not static}} 445 // [email protected]:* {{but in 'FirstModule' found method 'A' is static}} 446 #endif 447 448 #if defined(FIRST) 449 struct S4 { 450 virtual void A() {} 451 void B() {} 452 }; 453 #elif defined(SECOND) 454 struct S4 { 455 void A() {} 456 virtual void B() {} 457 }; 458 #else 459 S4 s4; 460 // [email protected]:* {{'Method::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not virtual}} 461 // [email protected]:* {{but in 'FirstModule' found method 'A' is virtual}} 462 #endif 463 464 #if defined(FIRST) 465 struct S5 { 466 virtual void A() = 0; 467 virtual void B() {}; 468 }; 469 #elif defined(SECOND) 470 struct S5 { 471 virtual void A() {} 472 virtual void B() = 0; 473 }; 474 #else 475 S5 *s5; 476 // [email protected]:* {{'Method::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is virtual}} 477 // [email protected]:* {{but in 'FirstModule' found method 'A' is pure virtual}} 478 #endif 479 480 #if defined(FIRST) 481 struct S6 { 482 inline void A() {} 483 }; 484 #elif defined(SECOND) 485 struct S6 { 486 void A() {} 487 }; 488 #else 489 S6 s6; 490 // [email protected]:* {{'Method::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not inline}} 491 // [email protected]:* {{but in 'FirstModule' found method 'A' is inline}} 492 #endif 493 494 #if defined(FIRST) 495 struct S7 { 496 void A() volatile {} 497 void A() {} 498 }; 499 #elif defined(SECOND) 500 struct S7 { 501 void A() {} 502 void A() volatile {} 503 }; 504 #else 505 S7 s7; 506 // [email protected]:* {{'Method::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not volatile}} 507 // [email protected]:* {{but in 'FirstModule' found method 'A' is volatile}} 508 #endif 509 510 #if defined(FIRST) 511 struct S8 { 512 void A() const {} 513 void A() {} 514 }; 515 #elif defined(SECOND) 516 struct S8 { 517 void A() {} 518 void A() const {} 519 }; 520 #else 521 S8 s8; 522 // [email protected]:* {{'Method::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not const}} 523 // [email protected]:* {{but in 'FirstModule' found method 'A' is const}} 524 #endif 525 526 #if defined(FIRST) 527 struct S9 { 528 void A(int x) {} 529 void A(int x, int y) {} 530 }; 531 #elif defined(SECOND) 532 struct S9 { 533 void A(int x, int y) {} 534 void A(int x) {} 535 }; 536 #else 537 S9 s9; 538 // [email protected]:* {{'Method::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' that has 2 parameters}} 539 // [email protected]:* {{but in 'FirstModule' found method 'A' that has 1 parameter}} 540 #endif 541 542 #if defined(FIRST) 543 struct S10 { 544 void A(int x) {} 545 void A(float x) {} 546 }; 547 #elif defined(SECOND) 548 struct S10 { 549 void A(float x) {} 550 void A(int x) {} 551 }; 552 #else 553 S10 s10; 554 // [email protected]:* {{'Method::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' with 1st parameter of type 'float'}} 555 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter of type 'int'}} 556 #endif 557 558 #if defined(FIRST) 559 struct S11 { 560 void A(int x); 561 }; 562 #elif defined(SECOND) 563 struct S11 { 564 void A(int y); 565 }; 566 #else 567 S11 s11; 568 // [email protected]:* {{'Method::S11' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' with 1st parameter named 'y'}} 569 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter named 'x'}} 570 #endif 571 572 #if defined(FIRST) 573 struct S12 { 574 void A(int x); 575 }; 576 #elif defined(SECOND) 577 struct S12 { 578 void A(int x = 1); 579 }; 580 #else 581 S12 s12; 582 // [email protected]:* {{'Method::S12' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' with 1st parameter without a default argument}} 583 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter with a default argument}} 584 #endif 585 586 #if defined(FIRST) 587 struct S13 { 588 void A(int x = 1 + 0); 589 }; 590 #elif defined(SECOND) 591 struct S13 { 592 void A(int x = 1); 593 }; 594 #else 595 S13 s13; 596 // [email protected]:* {{'Method::S13' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' with 1st parameter with a default argument}} 597 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter with a different default argument}} 598 #endif 599 600 #if defined(FIRST) 601 struct S14 { 602 void A(int x[2]); 603 }; 604 #elif defined(SECOND) 605 struct S14 { 606 void A(int x[3]); 607 }; 608 #else 609 S14 s14; 610 // [email protected]:* {{'Method::S14' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' with 1st parameter of type 'int *' decayed from 'int [3]'}} 611 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter of type 'int *' decayed from 'int [2]'}} 612 #endif 613 614 #if defined(FIRST) 615 struct S15 { 616 int A() { return 0; } 617 }; 618 #elif defined(SECOND) 619 struct S15 { 620 long A() { return 0; } 621 }; 622 #else 623 S15 s15; 624 // [email protected]:* {{'Method::S15::A' from module 'FirstModule' is not present in definition of 'Method::S15' in module 'SecondModule'}} 625 // [email protected]:* {{declaration of 'A' does not match}} 626 #endif 627 628 #define DECLS \ 629 void A(); \ 630 static void B(); \ 631 virtual void C(); \ 632 virtual void D() = 0; \ 633 inline void E(); \ 634 void F() const; \ 635 void G() volatile; \ 636 void H(int x); \ 637 void I(int x = 5 + 5); \ 638 void J(int); \ 639 void K(int x[2]); \ 640 int L(); 641 642 #if defined(FIRST) || defined(SECOND) 643 struct Valid1 { 644 DECLS 645 }; 646 #else 647 Valid1* v1; 648 #endif 649 650 #if defined(FIRST) || defined(SECOND) 651 struct Invalid1 { 652 DECLS 653 ACCESS 654 }; 655 #else 656 Invalid1* i1; 657 // [email protected]:* {{'Method::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 658 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 659 #endif 660 #undef DECLS 661 } // namespace Method 662 663 namespace Constructor { 664 #if defined(FIRST) 665 struct S1 { 666 S1() {} 667 void foo() {} 668 }; 669 #elif defined(SECOND) 670 struct S1 { 671 void foo() {} 672 S1() {} 673 }; 674 #else 675 S1 s1; 676 // [email protected]:* {{'Constructor::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'foo'}} 677 // [email protected]:* {{but in 'FirstModule' found constructor}} 678 #endif 679 680 #if defined(FIRST) 681 struct S2 { 682 S2(int) {} 683 S2(int, int) {} 684 }; 685 #elif defined(SECOND) 686 struct S2 { 687 S2(int, int) {} 688 S2(int) {} 689 }; 690 #else 691 S2* s2; 692 // [email protected]:* {{'Constructor::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found constructor that has 2 parameters}} 693 // [email protected]:* {{but in 'FirstModule' found constructor that has 1 parameter}} 694 #endif 695 696 #define DECLS(CLASS) \ 697 CLASS(int); \ 698 CLASS(double); \ 699 CLASS(int, int); 700 701 #if defined(FIRST) || defined(SECOND) 702 struct Valid1 { 703 DECLS(Valid1) 704 }; 705 #else 706 Valid1* v1; 707 #endif 708 709 #if defined(FIRST) || defined(SECOND) 710 struct Invalid1 { 711 DECLS(Invalid1) 712 ACCESS 713 }; 714 #else 715 Invalid1* i1; 716 // [email protected]:* {{'Constructor::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 717 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 718 #endif 719 #undef DECLS 720 } // namespace Constructor 721 722 namespace Destructor { 723 #if defined(FIRST) 724 struct S1 { 725 ~S1() {} 726 S1() {} 727 }; 728 #elif defined(SECOND) 729 struct S1 { 730 S1() {} 731 ~S1() {} 732 }; 733 #else 734 S1 s1; 735 // [email protected]:* {{'Destructor::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found constructor}} 736 // [email protected]:* {{but in 'FirstModule' found destructor}} 737 #endif 738 739 #if defined(FIRST) 740 struct S2 { 741 virtual ~S2() {} 742 void foo() {} 743 }; 744 #elif defined(SECOND) 745 struct S2 { 746 ~S2() {} 747 virtual void foo() {} 748 }; 749 #else 750 S2 s2; 751 // [email protected]:* {{'Destructor::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found destructor is not virtual}} 752 // [email protected]:* {{but in 'FirstModule' found destructor is virtual}} 753 #endif 754 755 #if defined(FIRST) || defined(SECOND) 756 struct Valid1 { 757 ~Valid1(); 758 }; 759 #else 760 Valid1 v1; 761 #endif 762 763 #if defined(FIRST) || defined(SECOND) 764 struct Invalid1 { 765 ~Invalid1(); 766 ACCESS 767 }; 768 #else 769 Invalid1 i1; 770 // [email protected]:* {{'Destructor::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 771 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 772 #endif 773 774 #if defined(FIRST) || defined(SECOND) 775 struct Valid2 { 776 virtual ~Valid2(); 777 }; 778 #else 779 Valid2 v2; 780 #endif 781 782 #if defined(FIRST) || defined(SECOND) 783 struct Invalid2 { 784 virtual ~Invalid2(); 785 ACCESS 786 }; 787 #else 788 Invalid2 i2; 789 // [email protected]:* {{'Destructor::Invalid2' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 790 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 791 #endif 792 } // namespace Destructor 793 794 namespace TypeDef { 795 #if defined(FIRST) 796 struct S1 { 797 typedef int a; 798 }; 799 #elif defined(SECOND) 800 struct S1 { 801 typedef double a; 802 }; 803 #else 804 S1 s1; 805 // [email protected]:* {{'TypeDef::S1::a' from module 'FirstModule' is not present in definition of 'TypeDef::S1' in module 'SecondModule'}} 806 // [email protected]:* {{declaration of 'a' does not match}} 807 #endif 808 809 #if defined(FIRST) 810 struct S2 { 811 typedef int a; 812 }; 813 #elif defined(SECOND) 814 struct S2 { 815 typedef int b; 816 }; 817 #else 818 S2 s2; 819 // [email protected]:* {{'TypeDef::S2::a' from module 'FirstModule' is not present in definition of 'TypeDef::S2' in module 'SecondModule'}} 820 // [email protected]:* {{definition has no member 'a'}} 821 #endif 822 823 #if defined(FIRST) 824 typedef int T; 825 struct S3 { 826 typedef T a; 827 }; 828 #elif defined(SECOND) 829 typedef double T; 830 struct S3 { 831 typedef T a; 832 }; 833 #else 834 S3 s3; 835 // [email protected]:* {{'TypeDef::S3::a' from module 'FirstModule' is not present in definition of 'TypeDef::S3' in module 'SecondModule'}} 836 // [email protected]:* {{declaration of 'a' does not match}} 837 #endif 838 839 #if defined(FIRST) 840 struct S4 { 841 typedef int a; 842 typedef int b; 843 }; 844 #elif defined(SECOND) 845 struct S4 { 846 typedef int b; 847 typedef int a; 848 }; 849 #else 850 S4 s4; 851 // [email protected]:* {{'TypeDef::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found typedef name 'b'}} 852 // [email protected]:* {{but in 'FirstModule' found typedef name 'a'}} 853 #endif 854 855 #if defined(FIRST) 856 struct S5 { 857 typedef int a; 858 typedef int b; 859 int x; 860 }; 861 #elif defined(SECOND) 862 struct S5 { 863 int x; 864 typedef int b; 865 typedef int a; 866 }; 867 #else 868 S5 s5; 869 // [email protected]:* {{'TypeDef::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field}} 870 // [email protected]:* {{but in 'FirstModule' found typedef}} 871 #endif 872 873 #if defined(FIRST) 874 typedef float F; 875 struct S6 { 876 typedef int a; 877 typedef F b; 878 }; 879 #elif defined(SECOND) 880 struct S6 { 881 typedef int a; 882 typedef float b; 883 }; 884 #else 885 S6 s6; 886 // [email protected]:* {{'TypeDef::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found typedef 'b' with underlying type 'float'}} 887 // [email protected]:* {{but in 'FirstModule' found typedef 'b' with different underlying type 'TypeDef::F' (aka 'float')}} 888 #endif 889 890 #define DECLS \ 891 typedef int A; \ 892 typedef double B; \ 893 typedef I C; 894 895 #if defined(FIRST) || defined(SECOND) 896 typedef int I; 897 #endif 898 899 #if defined(FIRST) || defined(SECOND) 900 struct Valid1 { 901 DECLS 902 }; 903 #else 904 Valid1 v1; 905 #endif 906 907 #if defined(FIRST) || defined(SECOND) 908 struct Invalid1 { 909 DECLS 910 ACCESS 911 }; 912 #else 913 Invalid1 i1; 914 // [email protected]:* {{'TypeDef::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 915 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 916 #endif 917 #undef DECLS 918 } // namespace TypeDef 919 920 namespace Using { 921 #if defined(FIRST) 922 struct S1 { 923 using a = int; 924 }; 925 #elif defined(SECOND) 926 struct S1 { 927 using a = double; 928 }; 929 #else 930 S1 s1; 931 // [email protected]:* {{'Using::S1::a' from module 'FirstModule' is not present in definition of 'Using::S1' in module 'SecondModule'}} 932 // [email protected]:* {{declaration of 'a' does not match}} 933 #endif 934 935 #if defined(FIRST) 936 struct S2 { 937 using a = int; 938 }; 939 #elif defined(SECOND) 940 struct S2 { 941 using b = int; 942 }; 943 #else 944 S2 s2; 945 // [email protected]:* {{'Using::S2::a' from module 'FirstModule' is not present in definition of 'Using::S2' in module 'SecondModule'}} 946 // [email protected]:* {{definition has no member 'a'}} 947 #endif 948 949 #if defined(FIRST) 950 typedef int T; 951 struct S3 { 952 using a = T; 953 }; 954 #elif defined(SECOND) 955 typedef double T; 956 struct S3 { 957 using a = T; 958 }; 959 #else 960 S3 s3; 961 // [email protected]:* {{'Using::S3::a' from module 'FirstModule' is not present in definition of 'Using::S3' in module 'SecondModule'}} 962 // [email protected]:* {{declaration of 'a' does not match}} 963 #endif 964 965 #if defined(FIRST) 966 struct S4 { 967 using a = int; 968 using b = int; 969 }; 970 #elif defined(SECOND) 971 struct S4 { 972 using b = int; 973 using a = int; 974 }; 975 #else 976 S4 s4; 977 // [email protected]:* {{'Using::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found type alias name 'b'}} 978 // [email protected]:* {{but in 'FirstModule' found type alias name 'a'}} 979 #endif 980 981 #if defined(FIRST) 982 struct S5 { 983 using a = int; 984 using b = int; 985 int x; 986 }; 987 #elif defined(SECOND) 988 struct S5 { 989 int x; 990 using b = int; 991 using a = int; 992 }; 993 #else 994 S5 s5; 995 // [email protected]:* {{'Using::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field}} 996 // [email protected]:* {{but in 'FirstModule' found type alias}} 997 #endif 998 999 #if defined(FIRST) 1000 typedef float F; 1001 struct S6 { 1002 using a = int; 1003 using b = F; 1004 }; 1005 #elif defined(SECOND) 1006 struct S6 { 1007 using a = int; 1008 using b = float; 1009 }; 1010 #else 1011 S6 s6; 1012 // [email protected]:* {{'Using::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found type alias 'b' with underlying type 'float'}} 1013 // [email protected]:* {{but in 'FirstModule' found type alias 'b' with different underlying type 'Using::F' (aka 'float')}} 1014 #endif 1015 1016 #if defined(FIRST) || defined(SECOND) 1017 using I = int; 1018 #endif 1019 1020 #define DECLS \ 1021 using A = int; \ 1022 using B = double; \ 1023 using C = I; 1024 1025 #if defined(FIRST) || defined(SECOND) 1026 struct Valid1 { 1027 DECLS 1028 }; 1029 #else 1030 Valid1 v1; 1031 #endif 1032 1033 #if defined(FIRST) || defined(SECOND) 1034 struct Invalid1 { 1035 DECLS 1036 ACCESS 1037 }; 1038 #else 1039 Invalid1 i1; 1040 // [email protected]:* {{'Using::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1041 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1042 #endif 1043 #undef DECLS 1044 } // namespace Using 1045 1046 namespace RecordType { 1047 #if defined(FIRST) 1048 struct B1 {}; 1049 struct S1 { 1050 B1 x; 1051 }; 1052 #elif defined(SECOND) 1053 struct A1 {}; 1054 struct S1 { 1055 A1 x; 1056 }; 1057 #else 1058 S1 s1; 1059 // [email protected]:* {{'RecordType::S1::x' from module 'FirstModule' is not present in definition of 'RecordType::S1' in module 'SecondModule'}} 1060 // [email protected]:* {{declaration of 'x' does not match}} 1061 #endif 1062 1063 #define DECLS \ 1064 Foo F; 1065 1066 #if defined(FIRST) || defined(SECOND) 1067 struct Foo {}; 1068 #endif 1069 1070 #if defined(FIRST) || defined(SECOND) 1071 struct Valid1 { 1072 DECLS 1073 }; 1074 #else 1075 Valid1 v1; 1076 #endif 1077 1078 #if defined(FIRST) || defined(SECOND) 1079 struct Invalid1 { 1080 DECLS 1081 ACCESS 1082 }; 1083 #else 1084 Invalid1 i1; 1085 // [email protected]:* {{'RecordType::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1086 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1087 #endif 1088 #undef DECLS 1089 } // namespace RecordType 1090 1091 namespace DependentType { 1092 #if defined(FIRST) 1093 template <class T> 1094 class S1 { 1095 typename T::typeA x; 1096 }; 1097 #elif defined(SECOND) 1098 template <class T> 1099 class S1 { 1100 typename T::typeB x; 1101 }; 1102 #else 1103 template<class T> 1104 using U1 = S1<T>; 1105 // [email protected]:* {{'DependentType::S1::x' from module 'FirstModule' is not present in definition of 'S1<T>' in module 'SecondModule'}} 1106 // [email protected]:* {{declaration of 'x' does not match}} 1107 #endif 1108 1109 #define DECLS \ 1110 typename T::typeA x; 1111 1112 #if defined(FIRST) || defined(SECOND) 1113 template <class T> 1114 struct Valid1 { 1115 DECLS 1116 }; 1117 #else 1118 template <class T> 1119 using V1 = Valid1<T>; 1120 #endif 1121 1122 #if defined(FIRST) || defined(SECOND) 1123 template <class T> 1124 struct Invalid1 { 1125 DECLS 1126 ACCESS 1127 }; 1128 #else 1129 template <class T> 1130 using I1 = Invalid1<T>; 1131 // [email protected]:* {{'DependentType::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1132 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1133 #endif 1134 #undef DECLS 1135 } // namespace DependentType 1136 1137 namespace ElaboratedType { 1138 #if defined(FIRST) 1139 namespace N1 { using type = double; } 1140 struct S1 { 1141 N1::type x; 1142 }; 1143 #elif defined(SECOND) 1144 namespace N1 { using type = int; } 1145 struct S1 { 1146 N1::type x; 1147 }; 1148 #else 1149 S1 s1; 1150 // [email protected]:* {{'ElaboratedType::S1::x' from module 'FirstModule' is not present in definition of 'ElaboratedType::S1' in module 'SecondModule'}} 1151 // [email protected]:* {{declaration of 'x' does not match}} 1152 #endif 1153 1154 #define DECLS \ 1155 NS::type x; 1156 1157 #if defined(FIRST) || defined(SECOND) 1158 namespace NS { using type = float; } 1159 #endif 1160 1161 #if defined(FIRST) || defined(SECOND) 1162 struct Valid1 { 1163 DECLS 1164 }; 1165 #else 1166 Valid1 v1; 1167 #endif 1168 1169 #if defined(FIRST) || defined(SECOND) 1170 struct Invalid1 { 1171 DECLS 1172 ACCESS 1173 }; 1174 #else 1175 Invalid1 i1; 1176 // [email protected]:* {{'ElaboratedType::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1177 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1178 #endif 1179 #undef DECLS 1180 } // namespace ElaboratedType 1181 1182 namespace Enum { 1183 #if defined(FIRST) 1184 enum A1 {}; 1185 struct S1 { 1186 A1 x; 1187 }; 1188 #elif defined(SECOND) 1189 enum A2 {}; 1190 struct S1 { 1191 A2 x; 1192 }; 1193 #else 1194 S1 s1; 1195 // [email protected]:* {{'Enum::S1::x' from module 'FirstModule' is not present in definition of 'Enum::S1' in module 'SecondModule'}} 1196 // [email protected]:* {{declaration of 'x' does not match}} 1197 #endif 1198 1199 #define DECLS \ 1200 E e = E1; 1201 1202 #if defined(FIRST) || defined(SECOND) 1203 enum E { E1, E2 }; 1204 #endif 1205 1206 #if defined(FIRST) || defined(SECOND) 1207 struct Valid1 { 1208 DECLS 1209 }; 1210 #else 1211 Valid1 v1; 1212 #endif 1213 1214 #if defined(FIRST) || defined(SECOND) 1215 struct Invalid1 { 1216 DECLS 1217 ACCESS 1218 }; 1219 #else 1220 Invalid1 i1; 1221 // [email protected]:* {{'Enum::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1222 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1223 #endif 1224 #undef DECLS 1225 } 1226 1227 namespace NestedNamespaceSpecifier { 1228 #if defined(FIRST) 1229 namespace LevelA1 { 1230 using Type = int; 1231 } 1232 1233 struct S1 { 1234 LevelA1::Type x; 1235 }; 1236 # elif defined(SECOND) 1237 namespace LevelB1 { 1238 namespace LevelC1 { 1239 using Type = int; 1240 } 1241 } 1242 1243 struct S1 { 1244 LevelB1::LevelC1::Type x; 1245 }; 1246 #else 1247 S1 s1; 1248 // [email protected]:* {{'NestedNamespaceSpecifier::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'LevelB1::LevelC1::Type' (aka 'int')}} 1249 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'LevelA1::Type' (aka 'int')}} 1250 #endif 1251 1252 #if defined(FIRST) 1253 namespace LevelA2 { using Type = int; } 1254 struct S2 { 1255 LevelA2::Type x; 1256 }; 1257 # elif defined(SECOND) 1258 struct S2 { 1259 int x; 1260 }; 1261 #else 1262 S2 s2; 1263 // [email protected]:* {{'NestedNamespaceSpecifier::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'int'}} 1264 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'LevelA2::Type' (aka 'int')}} 1265 #endif 1266 1267 namespace LevelA3 { using Type = int; } 1268 namespace LevelB3 { using Type = int; } 1269 #if defined(FIRST) 1270 struct S3 { 1271 LevelA3::Type x; 1272 }; 1273 # elif defined(SECOND) 1274 struct S3 { 1275 LevelB3::Type x; 1276 }; 1277 #else 1278 S3 s3; 1279 // [email protected]:* {{'NestedNamespaceSpecifier::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'LevelB3::Type' (aka 'int')}} 1280 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'LevelA3::Type' (aka 'int')}} 1281 #endif 1282 1283 #if defined(FIRST) 1284 struct TA4 { using Type = int; }; 1285 struct S4 { 1286 TA4::Type x; 1287 }; 1288 # elif defined(SECOND) 1289 struct TB4 { using Type = int; }; 1290 struct S4 { 1291 TB4::Type x; 1292 }; 1293 #else 1294 S4 s4; 1295 // [email protected]:* {{'NestedNamespaceSpecifier::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'TB4::Type' (aka 'int')}} 1296 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'TA4::Type' (aka 'int')}} 1297 #endif 1298 1299 #if defined(FIRST) 1300 struct T5 { using Type = int; }; 1301 struct S5 { 1302 T5::Type x; 1303 }; 1304 # elif defined(SECOND) 1305 namespace T5 { using Type = int; }; 1306 struct S5 { 1307 T5::Type x; 1308 }; 1309 #else 1310 S5 s5; 1311 // [email protected]:* {{'NestedNamespaceSpecifier::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'T5::Type' (aka 'int')}} 1312 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'T5::Type' (aka 'int')}} 1313 #endif 1314 1315 #if defined(FIRST) 1316 namespace N6 {using I = int;} 1317 struct S6 { 1318 NestedNamespaceSpecifier::N6::I x; 1319 }; 1320 # elif defined(SECOND) 1321 using I = int; 1322 struct S6 { 1323 ::NestedNamespaceSpecifier::I x; 1324 }; 1325 #else 1326 S6 s6; 1327 // [email protected]:* {{'NestedNamespaceSpecifier::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type '::NestedNamespaceSpecifier::I' (aka 'int')}} 1328 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'NestedNamespaceSpecifier::N6::I' (aka 'int')}} 1329 #endif 1330 1331 #if defined(FIRST) 1332 template <class T, class U> 1333 class S7 { 1334 typename T::type *x = {}; 1335 int z = x->T::foo(); 1336 }; 1337 #elif defined(SECOND) 1338 template <class T, class U> 1339 class S7 { 1340 typename T::type *x = {}; 1341 int z = x->U::foo(); 1342 }; 1343 #else 1344 template <class T, class U> 1345 using U7 = S7<T, U>; 1346 // [email protected]:* {{'NestedNamespaceSpecifier::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'z' with an initializer}} 1347 // [email protected]:* {{but in 'FirstModule' found field 'z' with a different initializer}} 1348 #endif 1349 1350 #if defined(FIRST) 1351 template <class T> 1352 class S8 { 1353 int x = T::template X<int>::value; 1354 }; 1355 #elif defined(SECOND) 1356 template <class T> 1357 class S8 { 1358 int x = T::template Y<int>::value; 1359 }; 1360 #else 1361 template <class T> 1362 using U8 = S8<T>; 1363 // [email protected]:* {{'NestedNamespaceSpecifier::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with an initializer}} 1364 // [email protected]:* {{but in 'FirstModule' found field 'x' with a different initializer}} 1365 #endif 1366 1367 #if defined(FIRST) 1368 namespace N9 { using I = int; } 1369 namespace O9 = N9; 1370 struct S9 { 1371 O9::I x; 1372 }; 1373 #elif defined(SECOND) 1374 namespace N9 { using I = int; } 1375 namespace P9 = N9; 1376 struct S9 { 1377 P9::I x; 1378 }; 1379 #else 1380 S9 s9; 1381 // [email protected]:* {{'NestedNamespaceSpecifier::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'P9::I' (aka 'int')}} 1382 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'O9::I' (aka 'int')}} 1383 #endif 1384 1385 namespace N10 { 1386 #if defined(FIRST) 1387 inline namespace A { struct X {}; } 1388 struct S10 { 1389 A::X x; 1390 }; 1391 #elif defined(SECOND) 1392 inline namespace B { struct X {}; } 1393 struct S10 { 1394 B::X x; 1395 }; 1396 #else 1397 S10 s10; 1398 // [email protected]:* {{'NestedNamespaceSpecifier::N10::S10::x' from module 'SecondModule' is not present in definition of 'NestedNamespaceSpecifier::N10::S10' in module 'FirstModule'}} 1399 // [email protected]:* {{declaration of 'x' does not match}} 1400 #endif 1401 } 1402 1403 #define DECLS \ 1404 NS1::Type a; \ 1405 NS1::NS2::Type b; \ 1406 NS1::S c; \ 1407 NS3::Type d; 1408 1409 #if defined(FIRST) || defined(SECOND) 1410 namespace NS1 { 1411 using Type = int; 1412 namespace NS2 { 1413 using Type = double; 1414 } 1415 struct S {}; 1416 } 1417 namespace NS3 = NS1; 1418 #endif 1419 1420 #if defined(FIRST) || defined(SECOND) 1421 struct Valid1 { 1422 DECLS 1423 }; 1424 #else 1425 Valid1 v1; 1426 #endif 1427 1428 #if defined(FIRST) || defined(SECOND) 1429 struct Invalid1 { 1430 DECLS 1431 ACCESS 1432 }; 1433 #else 1434 Invalid1 i1; 1435 // [email protected]:* {{'NestedNamespaceSpecifier::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1436 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1437 #endif 1438 #undef DECLS 1439 1440 #define DECLS \ 1441 typename T::type *x = {}; \ 1442 int y = x->T::foo(); \ 1443 int z = U::template X<int>::value; 1444 1445 #if defined(FIRST) || defined(SECOND) 1446 template <class T, class U> 1447 struct Valid2 { 1448 DECLS 1449 }; 1450 #else 1451 template <class T, class U> 1452 using V2 = Valid2<T, U>; 1453 #endif 1454 1455 #if defined(FIRST) || defined(SECOND) 1456 template <class T, class U> 1457 struct Invalid2 { 1458 DECLS 1459 ACCESS 1460 }; 1461 #else 1462 template <class T, class U> 1463 using I2 = Invalid2<T, U>; 1464 // [email protected]:* {{'NestedNamespaceSpecifier::Invalid2' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1465 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1466 #endif 1467 #undef DECLS 1468 } // namespace NestedNamespaceSpecifier 1469 1470 namespace TemplateSpecializationType { 1471 #if defined(FIRST) 1472 template <class T1> struct U1 {}; 1473 struct S1 { 1474 U1<int> u; 1475 }; 1476 #elif defined(SECOND) 1477 template <class T1, class T2> struct U1 {}; 1478 struct S1 { 1479 U1<int, int> u; 1480 }; 1481 #else 1482 S1 s1; 1483 // [email protected]:* {{'TemplateSpecializationType::S1::u' from module 'FirstModule' is not present in definition of 'TemplateSpecializationType::S1' in module 'SecondModule'}} 1484 // [email protected]:* {{declaration of 'u' does not match}} 1485 #endif 1486 1487 #if defined(FIRST) 1488 template <class T1> struct U2 {}; 1489 struct S2 { 1490 U2<int> u; 1491 }; 1492 #elif defined(SECOND) 1493 template <class T1> struct V1 {}; 1494 struct S2 { 1495 V1<int> u; 1496 }; 1497 #else 1498 S2 s2; 1499 // [email protected]:* {{'TemplateSpecializationType::S2::u' from module 'FirstModule' is not present in definition of 'TemplateSpecializationType::S2' in module 'SecondModule'}} 1500 // [email protected]:* {{declaration of 'u' does not match}} 1501 #endif 1502 1503 #define DECLS \ 1504 OneTemplateArg<int> x; \ 1505 OneTemplateArg<double> y; \ 1506 OneTemplateArg<char *> z; \ 1507 TwoTemplateArgs<int, int> a; \ 1508 TwoTemplateArgs<double, float> b; \ 1509 TwoTemplateArgs<short *, char> c; 1510 1511 #if defined(FIRST) || defined(SECOND) 1512 template <class T> struct OneTemplateArg {}; 1513 template <class T, class U> struct TwoTemplateArgs {}; 1514 #endif 1515 1516 #if defined(FIRST) || defined(SECOND) 1517 struct Valid1 { 1518 DECLS 1519 }; 1520 #else 1521 Valid1 v1; 1522 #endif 1523 1524 #if defined(FIRST) || defined(SECOND) 1525 struct Invalid1 { 1526 DECLS 1527 ACCESS 1528 }; 1529 #else 1530 Invalid1 i1; 1531 // [email protected]:* {{'TemplateSpecializationType::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1532 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1533 #endif 1534 #undef DECLS 1535 } // namespace TemplateSpecializationType 1536 1537 namespace TemplateArgument { 1538 #if defined(FIRST) 1539 template <class> struct U1{}; 1540 struct S1 { 1541 U1<int> x; 1542 }; 1543 #elif defined(SECOND) 1544 template <int> struct U1{}; 1545 struct S1 { 1546 U1<1> x; 1547 }; 1548 #else 1549 S1 s1; 1550 // [email protected]:* {{'TemplateArgument::S1::x' from module 'FirstModule' is not present in definition of 'TemplateArgument::S1' in module 'SecondModule'}} 1551 // [email protected]:* {{declaration of 'x' does not match}} 1552 #endif 1553 1554 #if defined(FIRST) 1555 template <int> struct U2{}; 1556 struct S2 { 1557 using T = U2<2>; 1558 }; 1559 #elif defined(SECOND) 1560 template <int> struct U2{}; 1561 struct S2 { 1562 using T = U2<(2)>; 1563 }; 1564 #else 1565 S2 s2; 1566 // [email protected]:* {{'TemplateArgument::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found type alias 'T' with underlying type 'U2<(2)>'}} 1567 // [email protected]:* {{but in 'FirstModule' found type alias 'T' with different underlying type 'U2<2>'}} 1568 #endif 1569 1570 #if defined(FIRST) 1571 template <int> struct U3{}; 1572 struct S3 { 1573 using T = U3<2>; 1574 }; 1575 #elif defined(SECOND) 1576 template <int> struct U3{}; 1577 struct S3 { 1578 using T = U3<1 + 1>; 1579 }; 1580 #else 1581 S3 s3; 1582 // [email protected]:* {{'TemplateArgument::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found type alias 'T' with underlying type 'U3<1 + 1>'}} 1583 // [email protected]:* {{but in 'FirstModule' found type alias 'T' with different underlying type 'U3<2>'}} 1584 #endif 1585 1586 #if defined(FIRST) 1587 template<class> struct T4a {}; 1588 template <template <class> class T> struct U4 {}; 1589 struct S4 { 1590 U4<T4a> x; 1591 }; 1592 #elif defined(SECOND) 1593 template<class> struct T4b {}; 1594 template <template <class> class T> struct U4 {}; 1595 struct S4 { 1596 U4<T4b> x; 1597 }; 1598 #else 1599 S4 s4; 1600 // [email protected]:* {{'TemplateArgument::S4::x' from module 'FirstModule' is not present in definition of 'TemplateArgument::S4' in module 'SecondModule'}} 1601 // [email protected]:* {{declaration of 'x' does not match}} 1602 #endif 1603 1604 #if defined(FIRST) 1605 template <class T> struct U5 {}; 1606 struct S5 { 1607 U5<int> x; 1608 }; 1609 #elif defined(SECOND) 1610 template <class T> struct U5 {}; 1611 struct S5 { 1612 U5<short> x; 1613 }; 1614 #else 1615 S5 s5; 1616 // [email protected]:* {{'TemplateArgument::S5::x' from module 'FirstModule' is not present in definition of 'TemplateArgument::S5' in module 'SecondModule'}} 1617 // [email protected]:* {{declaration of 'x' does not match}} 1618 #endif 1619 1620 #if defined(FIRST) 1621 template <class T> struct U6 {}; 1622 struct S6 { 1623 U6<int> x; 1624 U6<short> y; 1625 }; 1626 #elif defined(SECOND) 1627 template <class T> struct U6 {}; 1628 struct S6 { 1629 U6<short> y; 1630 U6<int> x; 1631 }; 1632 #else 1633 S6 s6; 1634 // [email protected]:* {{'TemplateArgument::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'y'}} 1635 // [email protected]:* {{but in 'FirstModule' found field 'x'}} 1636 #endif 1637 1638 #if defined(FIRST) 1639 struct S7 { 1640 template<int> void run() {} 1641 template<> void run<1>() {} 1642 }; 1643 #elif defined(SECOND) 1644 struct S7 { 1645 template<int> void run() {} 1646 void run() {} 1647 }; 1648 #else 1649 S7 s7; 1650 // [email protected]:* {{'TemplateArgument::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'run' with no template arguments}} 1651 // [email protected]:* {{but in 'FirstModule' found method 'run' with template arguments}} 1652 #endif 1653 1654 #if defined(FIRST) 1655 struct S8 { 1656 static int a, b; 1657 template<int&> void run() {} 1658 template<int&, int&> void run() {} 1659 template<> void run<a>() {} 1660 }; 1661 #elif defined(SECOND) 1662 struct S8 { 1663 static int a, b; 1664 template<int&> void run() {} 1665 template<int&, int&> void run() {} 1666 template<> void run<a, b>() {} 1667 }; 1668 #else 1669 S8 s8; 1670 // [email protected]:* {{'TemplateArgument::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'run' with 2 template arguments}} 1671 // [email protected]:* {{but in 'FirstModule' found method 'run' with 1 template argument}} 1672 #endif 1673 1674 #if defined(FIRST) 1675 struct S9 { 1676 static int a, b; 1677 template<int&> void run() {} 1678 template<> void run<a>() {} 1679 }; 1680 #elif defined(SECOND) 1681 struct S9 { 1682 static int a, b; 1683 template<int&> void run() {} 1684 template<> void run<b>() {} 1685 }; 1686 #else 1687 S9 s9; 1688 // [email protected]:* {{'TemplateArgument::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'run' with 'b' for 1st template argument}} 1689 // [email protected]:* {{but in 'FirstModule' found method 'run' with 'a' for 1st template argument}} 1690 #endif 1691 1692 #if defined(FIRST) 1693 struct S10 { 1694 static int a, b; 1695 template<int, int&...> void run() {} 1696 template<> void run<1, a>() {} 1697 }; 1698 #elif defined(SECOND) 1699 struct S10 { 1700 static int a, b; 1701 template<int, int&...> void run() {} 1702 template<> void run<1, b>() {} 1703 }; 1704 #else 1705 S10 s10; 1706 // [email protected]:* {{'TemplateArgument::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'run' with 'b' for 2nd template argument}} 1707 // [email protected]:* {{but in 'FirstModule' found method 'run' with 'a' for 2nd template argument}} 1708 #endif 1709 1710 #if defined(FIRST) 1711 struct S11 { 1712 static int a, b; 1713 template<int, int&...> void run() {} 1714 template<> void run<1, a>() {} 1715 }; 1716 #elif defined(SECOND) 1717 struct S11 { 1718 static int a, b; 1719 template<int, int&...> void run() {} 1720 template<> void run<1, a, a>() {} 1721 }; 1722 #else 1723 S11 s11; 1724 // [email protected]:* {{'TemplateArgument::S11' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'run' with 3 template arguments}} 1725 // [email protected]:* {{but in 'FirstModule' found method 'run' with 2 template arguments}} 1726 #endif 1727 1728 #define DECLS \ 1729 OneClass<int> a; \ 1730 OneInt<1> b; \ 1731 using c = OneClass<float>; \ 1732 using d = OneInt<2>; \ 1733 using e = OneInt<2 + 2>; \ 1734 OneTemplateClass<OneClass> f; \ 1735 OneTemplateInt<OneInt> g; \ 1736 static int i1, i2; \ 1737 template <int &> \ 1738 void Function() {} \ 1739 template <int &, int &> \ 1740 void Function() {} \ 1741 template <> \ 1742 void Function<i1>() {} \ 1743 template <> \ 1744 void Function<i2>() {} \ 1745 template <> \ 1746 void Function<i1, i2>() {} \ 1747 template <> \ 1748 void Function<i2, i1>() {} 1749 1750 #if defined(FIRST) || defined(SECOND) 1751 template <class> struct OneClass{}; 1752 template <int> struct OneInt{}; 1753 template <template <class> class> struct OneTemplateClass{}; 1754 template <template <int> class> struct OneTemplateInt{}; 1755 #endif 1756 1757 #if defined(FIRST) || defined(SECOND) 1758 struct Valid1 { 1759 DECLS 1760 }; 1761 #else 1762 Valid1 v1; 1763 #endif 1764 1765 #if defined(FIRST) || defined(SECOND) 1766 struct Invalid1 { 1767 DECLS 1768 ACCESS 1769 }; 1770 #else 1771 Invalid1 i1; 1772 // [email protected]:* {{'TemplateArgument::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1773 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1774 #endif 1775 #undef DECLS 1776 } // namespace TemplateArgument 1777 1778 namespace TemplateTypeParmType { 1779 #if defined(FIRST) 1780 template <class T1, class T2> 1781 struct S1 { 1782 T1 x; 1783 }; 1784 #elif defined(SECOND) 1785 template <class T1, class T2> 1786 struct S1 { 1787 T2 x; 1788 }; 1789 #else 1790 using TemplateTypeParmType::S1; 1791 // [email protected]:* {{'TemplateTypeParmType::S1::x' from module 'FirstModule' is not present in definition of 'S1<T1, T2>' in module 'SecondModule'}} 1792 // [email protected]:* {{declaration of 'x' does not match}} 1793 #endif 1794 1795 #if defined(FIRST) 1796 template <int ...Ts> 1797 struct U2 {}; 1798 template <int T, int U> 1799 class S2 { 1800 typedef U2<U, T> type; 1801 type x; 1802 }; 1803 #elif defined(SECOND) 1804 template <int ...Ts> 1805 struct U2 {}; 1806 template <int T, int U> 1807 class S2 { 1808 typedef U2<T, U> type; 1809 type x; 1810 }; 1811 #else 1812 using TemplateTypeParmType::S2; 1813 // [email protected]:* {{'TemplateTypeParmType::S2::x' from module 'FirstModule' is not present in definition of 'S2<T, U>' in module 'SecondModule'}} 1814 // [email protected]:* {{declaration of 'x' does not match}} 1815 // [email protected]:* {{'TemplateTypeParmType::S2::type' from module 'FirstModule' is not present in definition of 'S2<T, U>' in module 'SecondModule'}} 1816 // [email protected]:* {{declaration of 'type' does not match}} 1817 #endif 1818 1819 #define DECLS \ 1820 T t; \ 1821 U u; \ 1822 ParameterPack<T> a; \ 1823 ParameterPack<T, U> b; \ 1824 ParameterPack<U> c; \ 1825 ParameterPack<U, T> d; 1826 1827 #if defined(FIRST) || defined(SECOND) 1828 template <class ...Ts> struct ParameterPack {}; 1829 #endif 1830 1831 #if defined(FIRST) || defined(SECOND) 1832 template <class T, class U> 1833 struct Valid1 { 1834 DECLS 1835 }; 1836 #else 1837 using TemplateTypeParmType::Valid1; 1838 #endif 1839 1840 #if defined(FIRST) || defined(SECOND) 1841 template <class T, class U> 1842 struct Invalid1 { 1843 DECLS 1844 ACCESS 1845 }; 1846 #else 1847 using TemplateTypeParmType::Invalid1; 1848 // [email protected]:* {{'TemplateTypeParmType::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1849 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1850 #endif 1851 #undef DECLS 1852 } // namespace TemplateTypeParmType 1853 1854 namespace VarDecl { 1855 #if defined(FIRST) 1856 struct S1 { 1857 static int x; 1858 static int y; 1859 }; 1860 #elif defined(SECOND) 1861 struct S1 { 1862 static int y; 1863 static int x; 1864 }; 1865 #else 1866 S1 s1; 1867 // [email protected]:* {{'VarDecl::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member with name 'y'}} 1868 // [email protected]:* {{but in 'FirstModule' found data member with name 'x'}} 1869 #endif 1870 1871 #if defined(FIRST) 1872 struct S2 { 1873 static int x; 1874 }; 1875 #elif defined(SECOND) 1876 using I = int; 1877 struct S2 { 1878 static I x; 1879 }; 1880 #else 1881 S2 s2; 1882 // [email protected]:* {{'VarDecl::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' with type 'VarDecl::I' (aka 'int')}} 1883 // [email protected]:* {{but in 'FirstModule' found data member 'x' with different type 'int'}} 1884 #endif 1885 1886 #if defined(FIRST) 1887 struct S3 { 1888 static const int x = 1; 1889 }; 1890 #elif defined(SECOND) 1891 struct S3 { 1892 static const int x; 1893 }; 1894 #else 1895 S3 s3; 1896 // [email protected]:* {{'VarDecl::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' with an initializer}} 1897 // [email protected]:* {{but in 'FirstModule' found data member 'x' without an initializer}} 1898 #endif 1899 1900 #if defined(FIRST) 1901 struct S4 { 1902 static const int x = 1; 1903 }; 1904 #elif defined(SECOND) 1905 struct S4 { 1906 static const int x = 2; 1907 }; 1908 #else 1909 S4 s4; 1910 // [email protected]:* {{'VarDecl::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' with an initializer}} 1911 // [email protected]:* {{but in 'FirstModule' found data member 'x' with a different initializer}} 1912 #endif 1913 1914 #if defined(FIRST) 1915 struct S5 { 1916 static const int x = 1; 1917 }; 1918 #elif defined(SECOND) 1919 struct S5 { 1920 static constexpr int x = 1; 1921 }; 1922 #else 1923 S5 s5; 1924 // [email protected]:* {{'VarDecl::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' is not constexpr}} 1925 // [email protected]:* {{but in 'FirstModule' found data member 'x' is constexpr}} 1926 #endif 1927 1928 #if defined(FIRST) 1929 struct S6 { 1930 static const int x = 1; 1931 }; 1932 #elif defined(SECOND) 1933 struct S6 { 1934 static const int y = 1; 1935 }; 1936 #else 1937 S6 s6; 1938 // [email protected]:* {{'VarDecl::S6::x' from module 'FirstModule' is not present in definition of 'VarDecl::S6' in module 'SecondModule'}} 1939 // [email protected]:* {{definition has no member 'x'}} 1940 #endif 1941 1942 #if defined(FIRST) 1943 struct S7 { 1944 static const int x = 1; 1945 }; 1946 #elif defined(SECOND) 1947 struct S7 { 1948 static const unsigned x = 1; 1949 }; 1950 #else 1951 S7 s7; 1952 // [email protected]:* {{'VarDecl::S7::x' from module 'FirstModule' is not present in definition of 'VarDecl::S7' in module 'SecondModule'}} 1953 // [email protected]:* {{declaration of 'x' does not match}} 1954 #endif 1955 1956 #if defined(FIRST) 1957 struct S8 { 1958 public: 1959 static const int x = 1; 1960 }; 1961 #elif defined(SECOND) 1962 struct S8 { 1963 static const int x = 1; 1964 public: 1965 }; 1966 #else 1967 S8 s8; 1968 // [email protected]:* {{'VarDecl::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member}} 1969 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1970 #endif 1971 1972 #if defined(FIRST) 1973 struct S9 { 1974 static const int x = 1; 1975 }; 1976 #elif defined(SECOND) 1977 struct S9 { 1978 static int x; 1979 }; 1980 #else 1981 S9 s9; 1982 // [email protected]:* {{'VarDecl::S9::x' from module 'FirstModule' is not present in definition of 'VarDecl::S9' in module 'SecondModule'}} 1983 // [email protected]:* {{declaration of 'x' does not match}} 1984 #endif 1985 1986 #define DECLS \ 1987 static int a; \ 1988 static I b; \ 1989 static const int c = 1; \ 1990 static constexpr int d = 5; 1991 1992 #if defined(FIRST) || defined(SECOND) 1993 using I = int; 1994 #endif 1995 1996 #if defined(FIRST) || defined(SECOND) 1997 struct Valid1 { 1998 DECLS 1999 }; 2000 #else 2001 Valid1 v1; 2002 #endif 2003 2004 #if defined(FIRST) || defined(SECOND) 2005 struct Invalid1 { 2006 DECLS 2007 ACCESS 2008 }; 2009 #else 2010 Invalid1 i1; 2011 // [email protected]:* {{'VarDecl::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 2012 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 2013 #endif 2014 #undef DECLS 2015 } // namespace VarDecl 2016 2017 namespace Friend { 2018 #if defined(FIRST) 2019 struct T1 {}; 2020 struct S1 { 2021 friend class T1; 2022 }; 2023 #elif defined(SECOND) 2024 struct T1 {}; 2025 struct S1 { 2026 friend T1; 2027 }; 2028 #else 2029 S1 s1; 2030 // [email protected]:* {{'Friend::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found friend 'Friend::T1'}} 2031 // [email protected]:* {{but in 'FirstModule' found friend 'class T1'}} 2032 #endif 2033 2034 #if defined(FIRST) 2035 struct T2 {}; 2036 struct S2 { 2037 friend class T2; 2038 }; 2039 #elif defined(SECOND) 2040 struct T2 {}; 2041 struct S2 { 2042 friend struct T2; 2043 }; 2044 #else 2045 S2 s2; 2046 // [email protected]:* {{'Friend::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found friend 'struct T2'}} 2047 // [email protected]:* {{but in 'FirstModule' found friend 'class T2'}} 2048 #endif 2049 2050 #if defined(FIRST) 2051 struct T3 {}; 2052 struct S3 { 2053 friend const T3; 2054 }; 2055 #elif defined(SECOND) 2056 struct T3 {}; 2057 struct S3 { 2058 friend T3; 2059 }; 2060 #else 2061 S3 s3; 2062 // [email protected]:* {{'Friend::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found friend 'Friend::T3'}} 2063 // [email protected]:* {{but in 'FirstModule' found friend 'const Friend::T3'}} 2064 #endif 2065 2066 #if defined(FIRST) 2067 struct T4 {}; 2068 struct S4 { 2069 friend T4; 2070 }; 2071 #elif defined(SECOND) 2072 struct S4 { 2073 friend void T4(); 2074 }; 2075 #else 2076 S4 s4; 2077 // [email protected]:* {{'Friend::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found friend function}} 2078 // [email protected]:* {{but in 'FirstModule' found friend class}} 2079 #endif 2080 2081 #if defined(FIRST) 2082 struct S5 { 2083 friend void T5a(); 2084 }; 2085 #elif defined(SECOND) 2086 struct S5 { 2087 friend void T5b(); 2088 }; 2089 #else 2090 S5 s5; 2091 // [email protected]:* {{'Friend::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found friend function 'T5b'}} 2092 // [email protected]:* {{but in 'FirstModule' found friend function 'T5a'}} 2093 #endif 2094 2095 #define DECLS \ 2096 friend class FriendA; \ 2097 friend struct FriendB; \ 2098 friend FriendC; \ 2099 friend const FriendD; \ 2100 friend void Function(); 2101 2102 #if defined(FIRST) || defined(SECOND) 2103 class FriendA {}; 2104 class FriendB {}; 2105 class FriendC {}; 2106 class FriendD {}; 2107 #endif 2108 2109 #if defined(FIRST) || defined(SECOND) 2110 struct Valid1 { 2111 DECLS 2112 }; 2113 #else 2114 Valid1 v1; 2115 #endif 2116 2117 #if defined(FIRST) || defined(SECOND) 2118 struct Invalid1 { 2119 DECLS 2120 ACCESS 2121 }; 2122 #else 2123 Invalid1 i1; 2124 // [email protected]:* {{'Friend::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 2125 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 2126 #endif 2127 #undef DECLS 2128 } // namespace Friend 2129 2130 namespace TemplateParameters { 2131 #if defined(FIRST) 2132 template <class A> 2133 struct S1 {}; 2134 #elif defined(SECOND) 2135 template <class B> 2136 struct S1 {}; 2137 #else 2138 using TemplateParameters::S1; 2139 // [email protected]:* {{'TemplateParameters::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found template parameter 'B'}} 2140 // [email protected]:* {{but in 'FirstModule' found template parameter 'A'}} 2141 #endif 2142 2143 #if defined(FIRST) 2144 template <class A = double> 2145 struct S2 {}; 2146 #elif defined(SECOND) 2147 template <class A = int> 2148 struct S2 {}; 2149 #else 2150 using TemplateParameters::S2; 2151 // [email protected]:* {{'TemplateParameters::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found template parameter with default argument}} 2152 // [email protected]:* {{but in 'FirstModule' found template parameter with different default argument}} 2153 #endif 2154 2155 #if defined(FIRST) 2156 template <class A = int> 2157 struct S3 {}; 2158 #elif defined(SECOND) 2159 template <class A> 2160 struct S3 {}; 2161 #else 2162 using TemplateParameters::S3; 2163 // [email protected]:* {{'TemplateParameters::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found template parameter with no default argument}} 2164 // [email protected]:* {{but in 'FirstModule' found template parameter with default argument}} 2165 #endif 2166 2167 #if defined(FIRST) 2168 template <int A> 2169 struct S4 {}; 2170 #elif defined(SECOND) 2171 template <int A = 2> 2172 struct S4 {}; 2173 #else 2174 using TemplateParameters::S4; 2175 // [email protected]:* {{'TemplateParameters::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found template parameter with default argument}} 2176 // [email protected]:* {{but in 'FirstModule' found template parameter with no default argument}} 2177 #endif 2178 2179 #if defined(FIRST) 2180 template <int> class S5_first {}; 2181 template <template<int> class A = S5_first> 2182 struct S5 {}; 2183 #elif defined(SECOND) 2184 template <int> class S5_second {}; 2185 template <template<int> class A = S5_second> 2186 struct S5 {}; 2187 #else 2188 using TemplateParameters::S5; 2189 // [email protected]:* {{'TemplateParameters::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found template parameter with default argument}} 2190 // [email protected]:* {{but in 'FirstModule' found template parameter with different default argument}} 2191 #endif 2192 2193 #if defined(FIRST) 2194 template <class A> 2195 struct S6 {}; 2196 #elif defined(SECOND) 2197 template <class> 2198 struct S6 {}; 2199 #else 2200 using TemplateParameters::S6; 2201 // [email protected]:* {{'TemplateParameters::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found unnamed template parameter}} 2202 // [email protected]:* {{but in 'FirstModule' found template parameter 'A'}} 2203 #endif 2204 2205 #define DECLS 2206 2207 #if defined(FIRST) || defined(SECOND) 2208 template <class> class DefaultArg; 2209 #endif 2210 2211 #if defined(FIRST) || defined(SECOND) 2212 template <int, class, template <class> class, 2213 int A, class B, template <int> class C, 2214 int D = 1, class E = int, template <class F> class = DefaultArg> 2215 struct Valid1 { 2216 DECLS 2217 }; 2218 #else 2219 using TemplateParameters::Valid1; 2220 #endif 2221 2222 #if defined(FIRST) || defined(SECOND) 2223 template <int, class, template <class> class, 2224 int A, class B, template <int> class C, 2225 int D = 1, class E = int, template <class F> class = DefaultArg> 2226 struct Invalid1 { 2227 DECLS 2228 ACCESS 2229 }; 2230 #else 2231 using TemplateParameters::Invalid1; 2232 // [email protected]:* {{'TemplateParameters::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 2233 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 2234 #endif 2235 #undef DECLS 2236 } // namespace TemplateParameters 2237 2238 namespace BaseClass { 2239 #if defined(FIRST) 2240 struct B1 {}; 2241 struct S1 : B1 {}; 2242 #elif defined(SECOND) 2243 struct S1 {}; 2244 #else 2245 S1 s1; 2246 // [email protected]:* {{'BaseClass::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found 0 base classes}} 2247 // [email protected]:* {{but in 'FirstModule' found 1 base class}} 2248 #endif 2249 2250 #if defined(FIRST) 2251 struct S2 {}; 2252 #elif defined(SECOND) 2253 struct B2 {}; 2254 struct S2 : virtual B2 {}; 2255 #else 2256 S2 s2; 2257 // [email protected]:* {{'BaseClass::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1 base class}} 2258 // [email protected]:* {{but in 'FirstModule' found 0 base classes}} 2259 #endif 2260 2261 #if defined(FIRST) 2262 struct B3a {}; 2263 struct S3 : B3a {}; 2264 #elif defined(SECOND) 2265 struct B3b {}; 2266 struct S3 : virtual B3b {}; 2267 #else 2268 S3 s3; 2269 // [email protected]:* {{'BaseClass::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1 virtual base class}} 2270 // [email protected]:* {{but in 'FirstModule' found 0 virtual base classes}} 2271 #endif 2272 2273 #if defined(FIRST) 2274 struct B4a {}; 2275 struct S4 : B4a {}; 2276 #elif defined(SECOND) 2277 struct B4b {}; 2278 struct S4 : B4b {}; 2279 #else 2280 S4 s4; 2281 // [email protected]:* {{'BaseClass::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1st base class with type 'BaseClass::B4b'}} 2282 // [email protected]:* {{but in 'FirstModule' found 1st base class with different type 'BaseClass::B4a'}} 2283 #endif 2284 2285 #if defined(FIRST) 2286 struct B5a {}; 2287 struct S5 : virtual B5a {}; 2288 #elif defined(SECOND) 2289 struct B5a {}; 2290 struct S5 : B5a {}; 2291 #else 2292 S5 s5; 2293 // [email protected]:* {{'BaseClass::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found 0 virtual base classes}} 2294 // [email protected]:* {{but in 'FirstModule' found 1 virtual base class}} 2295 #endif 2296 2297 #if defined(FIRST) 2298 struct B6a {}; 2299 struct S6 : B6a {}; 2300 #elif defined(SECOND) 2301 struct B6a {}; 2302 struct S6 : virtual B6a {}; 2303 #else 2304 S6 s6; 2305 // [email protected]:* {{'BaseClass::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1 virtual base class}} 2306 // [email protected]:* {{but in 'FirstModule' found 0 virtual base classes}} 2307 #endif 2308 2309 #if defined(FIRST) 2310 struct B7a {}; 2311 struct S7 : protected B7a {}; 2312 #elif defined(SECOND) 2313 struct B7a {}; 2314 struct S7 : B7a {}; 2315 #else 2316 S7 s7; 2317 // [email protected]:* {{'BaseClass::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1st base class 'BaseClass::B7a' with no access specifier}} 2318 // [email protected]:* {{but in 'FirstModule' found 1st base class 'BaseClass::B7a' with protected access specifier}} 2319 #endif 2320 2321 #if defined(FIRST) 2322 struct B8a {}; 2323 struct S8 : public B8a {}; 2324 #elif defined(SECOND) 2325 struct B8a {}; 2326 struct S8 : private B8a {}; 2327 #else 2328 S8 s8; 2329 // [email protected]:* {{'BaseClass::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1st base class 'BaseClass::B8a' with private access specifier}} 2330 // [email protected]:* {{but in 'FirstModule' found 1st base class 'BaseClass::B8a' with public access specifier}} 2331 #endif 2332 2333 #if defined(FIRST) 2334 struct B9a {}; 2335 struct S9 : private B9a {}; 2336 #elif defined(SECOND) 2337 struct B9a {}; 2338 struct S9 : public B9a {}; 2339 #else 2340 S9 s9; 2341 // [email protected]:* {{'BaseClass::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1st base class 'BaseClass::B9a' with public access specifier}} 2342 // [email protected]:* {{but in 'FirstModule' found 1st base class 'BaseClass::B9a' with private access specifier}} 2343 #endif 2344 2345 #if defined(FIRST) 2346 struct B10a {}; 2347 struct S10 : B10a {}; 2348 #elif defined(SECOND) 2349 struct B10a {}; 2350 struct S10 : protected B10a {}; 2351 #else 2352 S10 s10; 2353 // [email protected]:* {{'BaseClass::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found 1st base class 'BaseClass::B10a' with protected access specifier}} 2354 // [email protected]:* {{but in 'FirstModule' found 1st base class 'BaseClass::B10a' with no access specifier}} 2355 #endif 2356 2357 #define DECLS 2358 2359 #if defined(FIRST) || defined(SECOND) 2360 struct Base1 {}; 2361 struct Base2 {}; 2362 struct Base3 {}; 2363 struct Base4 {}; 2364 struct Base5 {}; 2365 #endif 2366 2367 #if defined(FIRST) || defined(SECOND) 2368 struct Valid1 : 2369 Base1, virtual Base2, protected Base3, public Base4, private Base5 { 2370 2371 DECLS 2372 }; 2373 #else 2374 Valid1 v1; 2375 #endif 2376 2377 #if defined(FIRST) || defined(SECOND) 2378 struct Invalid1 : 2379 Base1, virtual Base2, protected Base3, public Base4, private Base5 { 2380 2381 DECLS 2382 ACCESS 2383 }; 2384 #else 2385 Invalid1 i1; 2386 // [email protected]:* {{'BaseClass::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 2387 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 2388 #endif 2389 #undef DECLS 2390 } // namespace BaseClass 2391 2392 namespace PointersAndReferences { 2393 #if defined(FIRST) || defined(SECOND) 2394 template<typename> struct Wrapper{}; 2395 #endif 2396 2397 #if defined(FIRST) 2398 struct S1 { 2399 Wrapper<int*> x; 2400 }; 2401 #elif defined(SECOND) 2402 struct S1 { 2403 Wrapper<float*> x; 2404 }; 2405 #else 2406 S1 s1; 2407 // [email protected]:* {{PointersAndReferences::S1::x' from module 'FirstModule' is not present in definition of 'PointersAndReferences::S1' in module 'SecondModule'}} 2408 // [email protected]:* {{declaration of 'x' does not match}} 2409 #endif 2410 2411 #if defined(FIRST) 2412 struct S2 { 2413 Wrapper<int &&> x; 2414 }; 2415 #elif defined(SECOND) 2416 struct S2 { 2417 Wrapper<float &&> x; 2418 }; 2419 #else 2420 S2 s2; 2421 // [email protected]:* {{PointersAndReferences::S2::x' from module 'FirstModule' is not present in definition of 'PointersAndReferences::S2' in module 'SecondModule'}} 2422 // [email protected]:* {{declaration of 'x' does not match}} 2423 #endif 2424 2425 #if defined(FIRST) 2426 struct S3 { 2427 Wrapper<int *> x; 2428 }; 2429 #elif defined(SECOND) 2430 struct S3 { 2431 Wrapper<float *> x; 2432 }; 2433 #else 2434 S3 s3; 2435 // [email protected]:* {{PointersAndReferences::S3::x' from module 'FirstModule' is not present in definition of 'PointersAndReferences::S3' in module 'SecondModule'}} 2436 // [email protected]:* {{declaration of 'x' does not match}} 2437 #endif 2438 2439 #if defined(FIRST) 2440 struct S4 { 2441 Wrapper<int &> x; 2442 }; 2443 #elif defined(SECOND) 2444 struct S4 { 2445 Wrapper<float &> x; 2446 }; 2447 #else 2448 S4 s4; 2449 // [email protected]:* {{PointersAndReferences::S4::x' from module 'FirstModule' is not present in definition of 'PointersAndReferences::S4' in module 'SecondModule'}} 2450 // [email protected]:* {{declaration of 'x' does not match}} 2451 #endif 2452 2453 #if defined(FIRST) 2454 struct S5 { 2455 Wrapper<S5 *> x; 2456 }; 2457 #elif defined(SECOND) 2458 struct S5 { 2459 Wrapper<const S5 *> x; 2460 }; 2461 #else 2462 S5 s5; 2463 // [email protected]:* {{'PointersAndReferences::S5::x' from module 'SecondModule' is not present in definition of 'PointersAndReferences::S5' in module 'FirstModule'}} 2464 // [email protected]:* {{declaration of 'x' does not match}} 2465 #endif 2466 2467 #if defined(FIRST) 2468 struct S6 { 2469 Wrapper<int &> x; 2470 }; 2471 #elif defined(SECOND) 2472 struct S6 { 2473 Wrapper<const int &> x; 2474 }; 2475 #else 2476 S6 s6; 2477 // [email protected]:* {{PointersAndReferences::S6::x' from module 'FirstModule' is not present in definition of 'PointersAndReferences::S6' in module 'SecondModule'}} 2478 // [email protected]:* {{declaration of 'x' does not match}} 2479 #endif 2480 2481 #define DECLS \ 2482 Wrapper<int *> x1; \ 2483 Wrapper<float *> x2; \ 2484 Wrapper<const float *> x3; \ 2485 Wrapper<int &> x4; \ 2486 Wrapper<int &&> x5; \ 2487 Wrapper<const int &> x6; \ 2488 Wrapper<S1 *> x7; \ 2489 Wrapper<S1 &> x8; \ 2490 Wrapper<S1 &&> x9; 2491 2492 #if defined(FIRST) || defined(SECOND) 2493 struct Valid1 { 2494 DECLS 2495 }; 2496 #else 2497 Valid1 v1; 2498 #endif 2499 2500 #if defined(FIRST) || defined(SECOND) 2501 struct Invalid1 { 2502 DECLS 2503 ACCESS 2504 }; 2505 #else 2506 Invalid1 i1; 2507 // [email protected]:* {{'PointersAndReferences::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 2508 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 2509 #endif 2510 #undef DECLS 2511 } // namespace PointersAndReferences 2512 2513 namespace FunctionTemplate { 2514 #if defined(FIRST) 2515 struct S1 { 2516 template <int, int> void foo(); 2517 }; 2518 #elif defined(SECOND) 2519 struct S1 { 2520 template <int> void foo(); 2521 }; 2522 #else 2523 S1 s1; 2524 // [email protected]:* {{'FunctionTemplate::S1::foo' from module 'FirstModule' is not present in definition of 'FunctionTemplate::S1' in module 'SecondModule'}} 2525 // [email protected]:* {{declaration of 'foo' does not match}} 2526 #endif 2527 2528 #if defined(FIRST) 2529 struct S2 { 2530 template <char> void foo(); 2531 }; 2532 #elif defined(SECOND) 2533 struct S2 { 2534 template <int> void foo(); 2535 }; 2536 #else 2537 S2 s2; 2538 // [email protected]:* {{'FunctionTemplate::S2::foo' from module 'FirstModule' is not present in definition of 'FunctionTemplate::S2' in module 'SecondModule'}} 2539 // [email protected]:* {{declaration of 'foo' does not match}} 2540 #endif 2541 2542 #if defined(FIRST) 2543 struct S3 { 2544 template <int x> void foo(); 2545 }; 2546 #elif defined(SECOND) 2547 struct S3 { 2548 template <int y> void foo(); 2549 }; 2550 #else 2551 S3 s3; 2552 // [email protected]:* {{'FunctionTemplate::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter named 'y'}} 2553 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter named 'x'}} 2554 #endif 2555 2556 #if defined(FIRST) 2557 struct S4 { 2558 template <int x> void foo(); 2559 }; 2560 #elif defined(SECOND) 2561 struct S4 { 2562 template <int x> void bar(); 2563 }; 2564 #else 2565 S4 s4; 2566 // [email protected]:* {{'FunctionTemplate::S4::foo' from module 'FirstModule' is not present in definition of 'FunctionTemplate::S4' in module 'SecondModule'}} 2567 // [email protected]:* {{definition has no member 'foo'}} 2568 #endif 2569 2570 #if defined(FIRST) 2571 struct S5 { 2572 template <int x> void foo(); 2573 }; 2574 #elif defined(SECOND) 2575 struct S5 { 2576 public: 2577 template <int x> void foo(); 2578 }; 2579 #else 2580 S5 s5; 2581 // [email protected]:* {{'FunctionTemplate::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 2582 // [email protected]:* {{but in 'FirstModule' found function template}} 2583 #endif 2584 2585 #if defined(FIRST) 2586 struct S6 { 2587 template <typename x = int> void foo(); 2588 }; 2589 #elif defined(SECOND) 2590 struct S6 { 2591 template <typename x> void foo(); 2592 }; 2593 #else 2594 S6 s6; 2595 // [email protected]:* {{'FunctionTemplate::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with no default argument}} 2596 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument}} 2597 #endif 2598 2599 #if defined(FIRST) 2600 struct S7 { 2601 template <typename x = void> void foo(); 2602 }; 2603 #elif defined(SECOND) 2604 struct S7 { 2605 template <typename x = int> void foo(); 2606 }; 2607 #else 2608 S7 s7; 2609 // [email protected]:* {{'FunctionTemplate::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with default argument 'int'}} 2610 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument 'void'}} 2611 #endif 2612 2613 #if defined(FIRST) 2614 template <int> 2615 struct U8 {}; 2616 struct S8 { 2617 template <template<int> class x = U8> void foo(); 2618 }; 2619 #elif defined(SECOND) 2620 template <int> 2621 struct T8 {}; 2622 struct S8{ 2623 template <template<int> class x = T8> void foo(); 2624 }; 2625 #else 2626 S8 s8; 2627 // [email protected]:* {{'FunctionTemplate::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with default argument 'T8'}} 2628 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument 'U8'}} 2629 #endif 2630 2631 #if defined(FIRST) 2632 template <int> 2633 struct U9 {}; 2634 struct S9 { S9(); 2635 template <template<int> class x = U9> void foo(); 2636 }; 2637 #elif defined(SECOND) 2638 struct S9 { S9(); 2639 template <template<int> class x> void foo(); 2640 }; 2641 #else 2642 S9 s9; 2643 // [email protected]:* {{'FunctionTemplate::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with no default argument}} 2644 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument}} 2645 #endif 2646 2647 #if defined(FIRST) 2648 struct S10 { 2649 template <template<int> class x> void foo(); 2650 template <template<typename> class x> void foo(); 2651 }; 2652 #elif defined(SECOND) 2653 struct S10 { 2654 template <template<typename> class x> void foo(); 2655 template <template<int> class x> void foo(); 2656 }; 2657 #else 2658 S10 s10; 2659 // [email protected]:* {{'FunctionTemplate::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with one type}} 2660 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with different type}} 2661 #endif 2662 2663 #if defined(FIRST) 2664 struct S11 { 2665 template <template<int> class x> void foo(); 2666 }; 2667 #elif defined(SECOND) 2668 struct S11 { 2669 template <template<int> class> void foo(); 2670 }; 2671 #else 2672 S11 s11; 2673 // [email protected]:* {{'FunctionTemplate::S11' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with no name}} 2674 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter named 'x'}} 2675 #endif 2676 2677 #if defined(FIRST) 2678 struct S12 { 2679 template <class> void foo(); 2680 template <class, class> void foo(); 2681 }; 2682 #elif defined(SECOND) 2683 struct S12 { 2684 template <class, class> void foo(); 2685 template <class> void foo(); 2686 }; 2687 #else 2688 S12 s12; 2689 // [email protected]:* {{'FunctionTemplate::S12' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 2 template parameters}} 2690 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1 template parameter}} 2691 #endif 2692 2693 #if defined(FIRST) 2694 struct S13 { 2695 template <class = int> void foo(); 2696 }; 2697 #elif defined(SECOND) 2698 struct S13 { 2699 template <class = void> void foo(); 2700 }; 2701 #else 2702 S13 s13; 2703 // [email protected]:* {{'FunctionTemplate::S13' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with default argument 'void'}} 2704 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument 'int'}} 2705 #endif 2706 2707 #if defined(FIRST) 2708 struct S14 { 2709 template <class = void> void foo(); 2710 }; 2711 #elif defined(SECOND) 2712 struct S14 { 2713 template <class> void foo(); 2714 }; 2715 #else 2716 S14 s14; 2717 // [email protected]:* {{'FunctionTemplate::S14' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with no default argument}} 2718 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument}} 2719 #endif 2720 2721 #if defined(FIRST) 2722 struct S15 { 2723 template <class> void foo(); 2724 }; 2725 #elif defined(SECOND) 2726 struct S15 { 2727 template <class = void> void foo(); 2728 }; 2729 #else 2730 S15 s15; 2731 // [email protected]:* {{'FunctionTemplate::S15' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with default argument}} 2732 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with no default argument}} 2733 #endif 2734 2735 #if defined(FIRST) 2736 struct S16 { 2737 template <short> void foo(); 2738 }; 2739 #elif defined(SECOND) 2740 struct S16 { 2741 template <short = 1> void foo(); 2742 }; 2743 #else 2744 S16 s16; 2745 // [email protected]:* {{'FunctionTemplate::S16' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with default argument}} 2746 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with no default argument}} 2747 #endif 2748 2749 #if defined(FIRST) 2750 struct S17 { 2751 template <short = 2> void foo(); 2752 }; 2753 #elif defined(SECOND) 2754 struct S17 { 2755 template <short = 1 + 1> void foo(); 2756 }; 2757 #else 2758 S17 s17; 2759 // [email protected]:* {{'FunctionTemplate::S17' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with default argument 1 + 1}} 2760 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with default argument 2}} 2761 #endif 2762 2763 #if defined(FIRST) 2764 struct S18 { 2765 template <short> void foo(); 2766 template <int> void foo(); 2767 }; 2768 #elif defined(SECOND) 2769 struct S18 { 2770 template <int> void foo(); 2771 template <short> void foo(); 2772 }; 2773 #else 2774 S18 s18; 2775 // [email protected]:* {{'FunctionTemplate::S18' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter with one type}} 2776 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter with different type}} 2777 #endif 2778 2779 #if defined(FIRST) 2780 struct S19 { 2781 template <short> void foo(); 2782 template <short...> void foo(); 2783 }; 2784 #elif defined(SECOND) 2785 struct S19 { 2786 template <short...> void foo(); 2787 template <short> void foo(); 2788 }; 2789 #else 2790 S19 s19; 2791 // [email protected]:* {{'FunctionTemplate::S19' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter being a template parameter pack}} 2792 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter not being a template parameter pack}} 2793 #endif 2794 2795 #if defined(FIRST) 2796 struct S20 { 2797 template <class> void foo(); 2798 template <class...> void foo(); 2799 }; 2800 #elif defined(SECOND) 2801 struct S20 { 2802 template <class...> void foo(); 2803 template <class> void foo(); 2804 }; 2805 #else 2806 S20 s20; 2807 // [email protected]:* {{'FunctionTemplate::S20' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter being a template parameter pack}} 2808 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter not being a template parameter pack}} 2809 #endif 2810 2811 #if defined(FIRST) 2812 struct S21 { 2813 template <template<class> class...> void foo(); 2814 template <template<class> class> void foo(); 2815 }; 2816 #elif defined(SECOND) 2817 struct S21 { 2818 template <template<class> class> void foo(); 2819 template <template<class> class...> void foo(); 2820 }; 2821 #else 2822 S21 s21; 2823 // [email protected]:* {{'FunctionTemplate::S21' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter not being a template parameter pack}} 2824 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template parameter being a template parameter pack}} 2825 #endif 2826 2827 #if defined(FIRST) 2828 struct S22 { 2829 template <template<class> class> void foo(); 2830 template <class> void foo(); 2831 template <int> void foo(); 2832 }; 2833 #elif defined(SECOND) 2834 struct S22 { 2835 template <class> void foo(); 2836 template <int> void foo(); 2837 template <template<class> class> void foo(); 2838 }; 2839 #else 2840 S22 s22; 2841 // [email protected]:* {{'FunctionTemplate::S22' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter being a type template parameter}} 2842 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template paramter being a template template parameter}} 2843 #endif 2844 2845 #if defined(FIRST) 2846 struct S23 { 2847 template <class> void foo(); 2848 template <int> void foo(); 2849 template <template<class> class> void foo(); 2850 }; 2851 #elif defined(SECOND) 2852 struct S23 { 2853 template <int> void foo(); 2854 template <template<class> class> void foo(); 2855 template <class> void foo(); 2856 }; 2857 #else 2858 S23 s23; 2859 // [email protected]:* {{'FunctionTemplate::S23' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter being a non-type template parameter}} 2860 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template paramter being a type template parameter}} 2861 #endif 2862 2863 #if defined(FIRST) 2864 struct S24 { 2865 template <int> void foo(); 2866 template <template<class> class> void foo(); 2867 template <class> void foo(); 2868 }; 2869 #elif defined(SECOND) 2870 struct S24 { 2871 template <template<class> class> void foo(); 2872 template <class> void foo(); 2873 template <int> void foo(); 2874 }; 2875 #else 2876 S24 s24; 2877 // [email protected]:* {{'FunctionTemplate::S24' has different definitions in different modules; first difference is definition in module 'SecondModule' found function template 'foo' with 1st template parameter being a template template parameter}} 2878 // [email protected]:* {{but in 'FirstModule' found function template 'foo' with 1st template paramter being a non-type template parameter}} 2879 #endif 2880 2881 #if defined(FIRST) 2882 struct S25 { 2883 template <int> void foo(); 2884 }; 2885 #elif defined(SECOND) 2886 struct S25 { 2887 public: 2888 template <int> void foo(); 2889 }; 2890 #else 2891 S25 s25; 2892 // [email protected]:* {{'FunctionTemplate::S25' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 2893 // [email protected]:* {{but in 'FirstModule' found function template}} 2894 #endif 2895 2896 #define DECLS \ 2897 template <int> \ 2898 void nontype1(); \ 2899 template <int x> \ 2900 void nontype2(); \ 2901 template <int, int> \ 2902 void nontype3(); \ 2903 template <int x = 5> \ 2904 void nontype4(); \ 2905 template <int... x> \ 2906 void nontype5(); \ 2907 \ 2908 template <class> \ 2909 void type1(); \ 2910 template <class x> \ 2911 void type2(); \ 2912 template <class, class> \ 2913 void type3(); \ 2914 template <class x = int> \ 2915 void type4(); \ 2916 template <class... x> \ 2917 void type5(); \ 2918 \ 2919 template <template <int> class> \ 2920 void template1(); \ 2921 template <template <int> class x> \ 2922 void template2(); \ 2923 template <template <int> class, template <int> class> \ 2924 void template3(); \ 2925 template <template <int> class x = U> \ 2926 void template4(); \ 2927 template <template <int> class... x> \ 2928 void template5(); 2929 2930 #if defined(FIRST) || defined(SECOND) 2931 template<int> 2932 struct U {}; 2933 struct Valid1 { 2934 DECLS 2935 }; 2936 #else 2937 Valid1 v1; 2938 #endif 2939 2940 #if defined(FIRST) || defined(SECOND) 2941 struct Invalid1 { 2942 DECLS 2943 ACCESS 2944 }; 2945 #else 2946 Invalid1 i1; 2947 // [email protected]:* {{'FunctionTemplate::Invalid1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 2948 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 2949 #endif 2950 #undef DECLS 2951 } 2952 2953 // Collection of interesting cases below. 2954 2955 // Naive parsing of AST can lead to cycles in processing. Ensure 2956 // self-references don't trigger an endless cycles of AST node processing. 2957 namespace SelfReference { 2958 #if defined(FIRST) 2959 template <template <int> class T> class Wrapper {}; 2960 2961 template <int N> class S { 2962 S(Wrapper<::SelfReference::S> &Ref) {} 2963 }; 2964 2965 struct Xx { 2966 struct Yy { 2967 }; 2968 }; 2969 2970 Xx::Xx::Xx::Yy yy; 2971 2972 namespace NNS { 2973 template <typename> struct Foo; 2974 template <template <class> class T = NNS::Foo> 2975 struct NestedNamespaceSpecifier {}; 2976 } 2977 #endif 2978 } // namespace SelfReference 2979 2980 namespace FriendFunction { 2981 #if defined(FIRST) 2982 void F(int = 0); 2983 struct S { friend void F(int); }; 2984 #elif defined(SECOND) 2985 void F(int); 2986 struct S { friend void F(int); }; 2987 #else 2988 S s; 2989 #endif 2990 2991 #if defined(FIRST) 2992 void G(int = 0); 2993 struct T { 2994 friend void G(int); 2995 2996 private: 2997 }; 2998 #elif defined(SECOND) 2999 void G(int); 3000 struct T { 3001 friend void G(int); 3002 3003 public: 3004 }; 3005 #else 3006 T t; 3007 // [email protected]:* {{'FriendFunction::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 3008 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 3009 #endif 3010 } // namespace FriendFunction 3011 3012 namespace ImplicitDecl { 3013 #if defined(FIRST) 3014 struct S { }; 3015 void S_Constructors() { 3016 // Trigger creation of implicit contructors 3017 S foo; 3018 S bar = foo; 3019 S baz(bar); 3020 } 3021 #elif defined(SECOND) 3022 struct S { }; 3023 #else 3024 S s; 3025 #endif 3026 3027 #if defined(FIRST) 3028 struct T { 3029 private: 3030 }; 3031 void T_Constructors() { 3032 // Trigger creation of implicit contructors 3033 T foo; 3034 T bar = foo; 3035 T baz(bar); 3036 } 3037 #elif defined(SECOND) 3038 struct T { 3039 public: 3040 }; 3041 #else 3042 T t; 3043 // [email protected]:* {{'ImplicitDecl::T' has different definitions in different modules; first difference is definition in module 'FirstModule' found private access specifier}} 3044 // [email protected]:* {{but in 'SecondModule' found public access specifier}} 3045 #endif 3046 3047 } // namespace ImplicitDecl 3048 3049 namespace TemplatedClass { 3050 #if defined(FIRST) 3051 template <class> 3052 struct S {}; 3053 #elif defined(SECOND) 3054 template <class> 3055 struct S {}; 3056 #else 3057 S<int> s; 3058 #endif 3059 3060 #if defined(FIRST) 3061 template <class> 3062 struct T { 3063 private: 3064 }; 3065 #elif defined(SECOND) 3066 template <class> 3067 struct T { 3068 public: 3069 }; 3070 #else 3071 T<int> t; 3072 // [email protected]:* {{'TemplatedClass::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 3073 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 3074 #endif 3075 } // namespace TemplatedClass 3076 3077 namespace TemplateClassWithField { 3078 #if defined(FIRST) 3079 template <class A> 3080 struct S { 3081 A a; 3082 }; 3083 #elif defined(SECOND) 3084 template <class A> 3085 struct S { 3086 A a; 3087 }; 3088 #else 3089 S<int> s; 3090 #endif 3091 3092 #if defined(FIRST) 3093 template <class A> 3094 struct T { 3095 A a; 3096 3097 private: 3098 }; 3099 #elif defined(SECOND) 3100 template <class A> 3101 struct T { 3102 A a; 3103 3104 public: 3105 }; 3106 #else 3107 T<int> t; 3108 // [email protected]:* {{'TemplateClassWithField::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 3109 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 3110 #endif 3111 } // namespace TemplateClassWithField 3112 3113 namespace TemplateClassWithTemplateField { 3114 #if defined(FIRST) 3115 template <class A> 3116 class WrapperS; 3117 template <class A> 3118 struct S { 3119 WrapperS<A> a; 3120 }; 3121 #elif defined(SECOND) 3122 template <class A> 3123 class WrapperS; 3124 template <class A> 3125 struct S { 3126 WrapperS<A> a; 3127 }; 3128 #else 3129 template <class A> 3130 class WrapperS{}; 3131 S<int> s; 3132 #endif 3133 3134 #if defined(FIRST) 3135 template <class A> 3136 class WrapperT; 3137 template <class A> 3138 struct T { 3139 WrapperT<A> a; 3140 3141 public: 3142 }; 3143 #elif defined(SECOND) 3144 template <class A> 3145 class WrapperT; 3146 template <class A> 3147 struct T { 3148 WrapperT<A> a; 3149 3150 private: 3151 }; 3152 #else 3153 template <class A> 3154 class WrapperT{}; 3155 T<int> t; 3156 // [email protected]:* {{'TemplateClassWithTemplateField::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 3157 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 3158 #endif 3159 } // namespace TemplateClassWithTemplateField 3160 3161 namespace EnumWithForwardDeclaration { 3162 #if defined(FIRST) 3163 enum E : int; 3164 struct S { 3165 void get(E) {} 3166 }; 3167 #elif defined(SECOND) 3168 enum E : int { A, B }; 3169 struct S { 3170 void get(E) {} 3171 }; 3172 #else 3173 S s; 3174 #endif 3175 3176 #if defined(FIRST) 3177 struct T { 3178 void get(E) {} 3179 public: 3180 }; 3181 #elif defined(SECOND) 3182 struct T { 3183 void get(E) {} 3184 private: 3185 }; 3186 #else 3187 T t; 3188 // [email protected]:* {{'EnumWithForwardDeclaration::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 3189 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 3190 #endif 3191 } // namespace EnumWithForwardDeclaration 3192 3193 namespace StructWithForwardDeclaration { 3194 #if defined(FIRST) 3195 struct P {}; 3196 struct S { 3197 struct P *ptr; 3198 }; 3199 #elif defined(SECOND) 3200 struct S { 3201 struct P *ptr; 3202 }; 3203 #else 3204 S s; 3205 #endif 3206 3207 #if defined(FIRST) 3208 struct Q {}; 3209 struct T { 3210 struct Q *ptr; 3211 public: 3212 }; 3213 #elif defined(SECOND) 3214 struct T { 3215 struct Q *ptr; 3216 private: 3217 }; 3218 #else 3219 T t; 3220 // [email protected]:* {{'StructWithForwardDeclaration::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 3221 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 3222 #endif 3223 } // namespace StructWithForwardDeclaration 3224 3225 namespace StructWithForwardDeclarationNoDefinition { 3226 #if defined(FIRST) 3227 struct P; 3228 struct S { 3229 struct P *ptr; 3230 }; 3231 #elif defined(SECOND) 3232 struct S { 3233 struct P *ptr; 3234 }; 3235 #else 3236 S s; 3237 #endif 3238 3239 #if defined(FIRST) 3240 struct Q; 3241 struct T { 3242 struct Q *ptr; 3243 3244 public: 3245 }; 3246 #elif defined(SECOND) 3247 struct T { 3248 struct Q *ptr; 3249 3250 private: 3251 }; 3252 #else 3253 T t; 3254 // [email protected]:* {{'StructWithForwardDeclarationNoDefinition::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 3255 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 3256 #endif 3257 } // namespace StructWithForwardDeclarationNoDefinition 3258 3259 namespace LateParsedDefaultArgument { 3260 #if defined(FIRST) 3261 template <typename T> 3262 struct S { 3263 struct R { 3264 void foo(T x = 0) {} 3265 }; 3266 }; 3267 #elif defined(SECOND) 3268 #else 3269 void run() { 3270 S<int>::R().foo(); 3271 } 3272 #endif 3273 } // namespace LateParsedDefaultArgument 3274 3275 namespace LateParsedDefaultArgument { 3276 #if defined(FIRST) 3277 template <typename alpha> struct Bravo { 3278 void charlie(bool delta = false) {} 3279 }; 3280 typedef Bravo<char> echo; 3281 echo foxtrot; 3282 3283 Bravo<char> golf; 3284 #elif defined(SECOND) 3285 #else 3286 #endif 3287 } // LateParsedDefaultArgument 3288 3289 namespace DifferentParameterNameInTemplate { 3290 #if defined(FIRST) || defined(SECOND) 3291 template <typename T> 3292 struct S { 3293 typedef T Type; 3294 3295 static void Run(const Type *name_one); 3296 }; 3297 3298 template <typename T> 3299 void S<T>::Run(const T *name_two) {} 3300 3301 template <typename T> 3302 struct Foo { 3303 ~Foo() { Handler::Run(nullptr); } 3304 Foo() {} 3305 3306 class Handler : public S<T> {}; 3307 3308 void Get(typename Handler::Type *x = nullptr) {} 3309 void Add() { Handler::Run(nullptr); } 3310 }; 3311 #endif 3312 3313 #if defined(FIRST) 3314 struct Beta; 3315 3316 struct Alpha { 3317 Alpha(); 3318 void Go() { betas.Get(); } 3319 Foo<Beta> betas; 3320 }; 3321 3322 #elif defined(SECOND) 3323 struct Beta {}; 3324 3325 struct BetaHelper { 3326 void add_Beta() { betas.Add(); } 3327 Foo<Beta> betas; 3328 }; 3329 3330 #else 3331 Alpha::Alpha() {} 3332 #endif 3333 } // DifferentParameterNameInTemplate 3334 3335 namespace ParameterTest { 3336 #if defined(FIRST) 3337 class X {}; 3338 template <typename G> 3339 class S { 3340 public: 3341 typedef G Type; 3342 static inline G *Foo(const G *a, int * = nullptr); 3343 }; 3344 3345 template<typename G> 3346 G* S<G>::Foo(const G* aaaa, int*) {} 3347 #elif defined(SECOND) 3348 template <typename G> 3349 class S { 3350 public: 3351 typedef G Type; 3352 static inline G *Foo(const G *a, int * = nullptr); 3353 }; 3354 3355 template<typename G> 3356 G* S<G>::Foo(const G* asdf, int*) {} 3357 #else 3358 S<X> s; 3359 #endif 3360 } // ParameterTest 3361 3362 namespace MultipleTypedefs { 3363 #if defined(FIRST) 3364 typedef int B1; 3365 typedef B1 A1; 3366 struct S1 { 3367 A1 x; 3368 }; 3369 #elif defined(SECOND) 3370 typedef int A1; 3371 struct S1 { 3372 A1 x; 3373 }; 3374 #else 3375 S1 s1; 3376 #endif 3377 3378 #if defined(FIRST) 3379 struct T2 { int x; }; 3380 typedef T2 B2; 3381 typedef B2 A2; 3382 struct S2 { 3383 T2 x; 3384 }; 3385 #elif defined(SECOND) 3386 struct T2 { int x; }; 3387 typedef T2 A2; 3388 struct S2 { 3389 T2 x; 3390 }; 3391 #else 3392 S2 s2; 3393 #endif 3394 3395 #if defined(FIRST) 3396 using A3 = const int; 3397 using B3 = volatile A3; 3398 struct S3 { 3399 B3 x = 1; 3400 }; 3401 #elif defined(SECOND) 3402 using A3 = volatile const int; 3403 using B3 = A3; 3404 struct S3 { 3405 B3 x = 1; 3406 }; 3407 #else 3408 S3 s3; 3409 #endif 3410 3411 #if defined(FIRST) 3412 using A4 = int; 3413 using B4 = A4; 3414 struct S4 { 3415 B4 x; 3416 }; 3417 #elif defined(SECOND) 3418 using A4 = int; 3419 using B4 = ::MultipleTypedefs::A4; 3420 struct S4 { 3421 B4 x; 3422 }; 3423 #else 3424 S4 s4; 3425 #endif 3426 3427 #if defined(FIRST) 3428 using A5 = int; 3429 using B5 = MultipleTypedefs::A5; 3430 struct S5 { 3431 B5 x; 3432 }; 3433 #elif defined(SECOND) 3434 using A5 = int; 3435 using B5 = ::MultipleTypedefs::A5; 3436 struct S5 { 3437 B5 x; 3438 }; 3439 #else 3440 S5 s5; 3441 #endif 3442 } // MultipleTypedefs 3443 3444 namespace DefaultArguments { 3445 #if defined(FIRST) 3446 template <typename T> 3447 struct S { 3448 struct R { 3449 void foo(T x = 0); 3450 }; 3451 }; 3452 #elif defined(SECOND) 3453 template <typename T> 3454 struct S { 3455 struct R { 3456 void foo(T x = 1); 3457 }; 3458 }; 3459 #else 3460 void run() { 3461 S<int>::R().foo(); 3462 } 3463 // [email protected]:* {{'DefaultArguments::S::R' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'foo' with 1st parameter with a default argument}} 3464 // [email protected]:* {{but in 'FirstModule' found method 'foo' with 1st parameter with a different default argument}} 3465 #endif 3466 3467 #if defined(FIRST) 3468 template <typename alpha> struct Bravo { 3469 void charlie(bool delta = false); 3470 }; 3471 typedef Bravo<char> echo; 3472 echo foxtrot; 3473 #elif defined(SECOND) 3474 template <typename alpha> struct Bravo { 3475 void charlie(bool delta = (false)); 3476 }; 3477 typedef Bravo<char> echo; 3478 echo foxtrot; 3479 #else 3480 Bravo<char> golf; 3481 // [email protected]:* {{'DefaultArguments::Bravo' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'charlie' with 1st parameter with a default argument}} 3482 // [email protected]:* {{but in 'FirstModule' found method 'charlie' with 1st parameter with a different default argument}} 3483 #endif 3484 } // namespace DefaultArguments 3485 3486 namespace FunctionDecl { 3487 #if defined(FIRST) 3488 struct S1 {}; 3489 S1 s1a; 3490 #elif defined(SECOND) 3491 struct S1 {}; 3492 #else 3493 S1 s1; 3494 #endif 3495 3496 #if defined(FIRST) 3497 struct S2 { 3498 S2() = default; 3499 }; 3500 S2 s2a = S2(); 3501 #elif defined(SECOND) 3502 struct S2 { 3503 S2() = default; 3504 }; 3505 #else 3506 S2 s2; 3507 #endif 3508 3509 #if defined(FIRST) 3510 struct S3 { 3511 S3() = delete; 3512 }; 3513 S3* s3c; 3514 #elif defined(SECOND) 3515 struct S3 { 3516 S3() = delete; 3517 }; 3518 #else 3519 S3* s3; 3520 #endif 3521 3522 #if defined(FIRST) || defined(SECOND) 3523 int F1(int x, float y = 2.7) { return 1; } 3524 #else 3525 int I1 = F1(1); 3526 #endif 3527 3528 #if defined(FIRST) 3529 int F2() { return 1; } 3530 #elif defined(SECOND) 3531 double F2() { return 1; } 3532 #else 3533 int I2 = F2(); 3534 // expected-error@-1 {{call to 'F2' is ambiguous}} 3535 // [email protected]:* {{candidate function}} 3536 // [email protected]:* {{candidate function}} 3537 #endif 3538 3539 #if defined(FIRST) 3540 int F3(float) { return 1; } 3541 #elif defined(SECOND) 3542 int F3(double) { return 1; } 3543 #else 3544 int I3 = F3(1); 3545 // expected-error@-1 {{call to 'F3' is ambiguous}} 3546 // [email protected]:* {{candidate function}} 3547 // [email protected]:* {{candidate function}} 3548 #endif 3549 3550 #if defined(FIRST) 3551 int F4(int x) { return 1; } 3552 #elif defined(SECOND) 3553 int F4(int y) { return 1; } 3554 #else 3555 int I4 = F4(1); 3556 // [email protected]:* {{'FunctionDecl::F4' has different definitions in different modules; definition in module 'SecondModule' first difference is 1st parameter with name 'y'}} 3557 // [email protected]:* {{but in 'FirstModule' found 1st parameter with name 'x'}} 3558 #endif 3559 3560 #if defined(FIRST) 3561 int F5(int x) { return 1; } 3562 #elif defined(SECOND) 3563 int F5(int x = 1) { return 1; } 3564 #else 3565 int I5 = F6(1); 3566 // [email protected]:* {{'FunctionDecl::F5' has different definitions in different modules; definition in module 'SecondModule' first difference is 1st parameter without a default argument}} 3567 // [email protected]:* {{but in 'FirstModule' found 1st parameter with a default argument}} 3568 #endif 3569 3570 #if defined(FIRST) 3571 int F6(int x = 2) { return 1; } 3572 #elif defined(SECOND) 3573 int F6(int x = 1) { return 1; } 3574 #else 3575 int I6 = F6(1); 3576 // [email protected]:* {{'FunctionDecl::F6' has different definitions in different modules; definition in module 'SecondModule' first difference is 1st parameter with a default argument}} 3577 // [email protected]:* {{but in 'FirstModule' found 1st parameter with a different default argument}} 3578 #endif 3579 3580 using I = int; 3581 #if defined(FIRST) 3582 I F7() { return 0; } 3583 #elif defined(SECOND) 3584 int F7() { return 0; } 3585 #else 3586 int I7 = F7(); 3587 // [email protected]:* {{'FunctionDecl::F7' has different definitions in different modules; definition in module 'SecondModule' first difference is return type is 'int'}} 3588 // [email protected]:* {{but in 'FirstModule' found different return type 'FunctionDecl::I' (aka 'int')}} 3589 #endif 3590 3591 #if defined(FIRST) 3592 int F8(int) { return 0; } 3593 #elif defined(SECOND) 3594 int F8(I) { return 0; } 3595 #else 3596 int I8 = F8(1); 3597 // [email protected]:* {{'FunctionDecl::F8' has different definitions in different modules; definition in module 'SecondModule' first difference is 1st parameter with type 'FunctionDecl::I' (aka 'int')}} 3598 // [email protected]:* {{but in 'FirstModule' found 1st parameter with type 'int'}} 3599 #endif 3600 3601 #if defined(FIRST) 3602 int F9(int[1]) { return 0; } 3603 #elif defined(SECOND) 3604 int F9(int[2]) { return 0; } 3605 #else 3606 int I9 = F9(nullptr); 3607 // [email protected]:* {{'FunctionDecl::F9' has different definitions in different modules; definition in module 'SecondModule' first difference is 1st parameter with type 'int *' decayed from 'int [2]'}} 3608 // [email protected]:* {{but in 'FirstModule' found 1st parameter with type 'int *' decayed from 'int [1]'}} 3609 #endif 3610 3611 #if defined(FIRST) 3612 int F10() { return 1; } 3613 #elif defined(SECOND) 3614 int F10() { return 2; } 3615 #else 3616 int I10 = F10(); 3617 #endif 3618 // [email protected]:* {{'FunctionDecl::F10' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}} 3619 // [email protected]:* {{but in 'FirstModule' found a different body}} 3620 3621 #if defined(FIRST) 3622 struct S11 { 3623 template <int> void foo(); 3624 }; 3625 #elif defined(SECOND) 3626 struct S11 { 3627 template <int> void foo(); 3628 }; 3629 template <int> void S11::foo() {} 3630 #else 3631 S11 s11; 3632 #endif 3633 3634 } // namespace FunctionDecl 3635 3636 namespace DeclTemplateArguments { 3637 #if defined(FIRST) 3638 int foo() { return 1; } 3639 int bar() { return foo(); } 3640 #elif defined(SECOND) 3641 template <class T = int> 3642 int foo() { return 2; } 3643 int bar() { return foo<>(); } 3644 #else 3645 int num = bar(); 3646 // [email protected]:* {{'DeclTemplateArguments::bar' has different definitions in different modules; definition in module 'SecondModule' first difference is function body}} 3647 // [email protected]:* {{but in 'FirstModule' found a different body}} 3648 #endif 3649 } 3650 3651 // Keep macros contained to one file. 3652 #ifdef FIRST 3653 #undef FIRST 3654 #endif 3655 3656 #ifdef SECOND 3657 #undef SECOND 3658 #endif 3659 3660 #ifdef ACCESS 3661 #undef ACCESS 3662 #endif 3663