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 // Build module map file 16 // RUN: echo "module FirstModule {" >> %t/Inputs/module.map 17 // RUN: echo " header \"first.h\"" >> %t/Inputs/module.map 18 // RUN: echo "}" >> %t/Inputs/module.map 19 // RUN: echo "module SecondModule {" >> %t/Inputs/module.map 20 // RUN: echo " header \"second.h\"" >> %t/Inputs/module.map 21 // RUN: echo "}" >> %t/Inputs/module.map 22 23 // Run test 24 // RUN: %clang_cc1 -fmodules -fimplicit-module-maps -fmodules-cache-path=%t/cache -x c++ -I%t/Inputs -verify %s -std=c++1z 25 26 #if !defined(FIRST) && !defined(SECOND) 27 #include "first.h" 28 #include "second.h" 29 #endif 30 31 namespace AccessSpecifiers { 32 #if defined(FIRST) 33 struct S1 { 34 }; 35 #elif defined(SECOND) 36 struct S1 { 37 private: 38 }; 39 #else 40 S1 s1; 41 // [email protected]:* {{'AccessSpecifiers::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 42 // [email protected]:* {{but in 'FirstModule' found end of class}} 43 #endif 44 45 #if defined(FIRST) 46 struct S2 { 47 public: 48 }; 49 #elif defined(SECOND) 50 struct S2 { 51 protected: 52 }; 53 #else 54 S2 s2; 55 // [email protected]:* {{'AccessSpecifiers::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found protected access specifier}} 56 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 57 #endif 58 } // namespace AccessSpecifiers 59 60 namespace StaticAssert { 61 #if defined(FIRST) 62 struct S1 { 63 static_assert(1 == 1, "First"); 64 }; 65 #elif defined(SECOND) 66 struct S1 { 67 static_assert(1 == 1, "Second"); 68 }; 69 #else 70 S1 s1; 71 // [email protected]:* {{'StaticAssert::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found static assert with message}} 72 // [email protected]:* {{but in 'FirstModule' found static assert with different message}} 73 #endif 74 75 #if defined(FIRST) 76 struct S2 { 77 static_assert(2 == 2, "Message"); 78 }; 79 #elif defined(SECOND) 80 struct S2 { 81 static_assert(2 == 2); 82 }; 83 #else 84 S2 s2; 85 // [email protected]:* {{'StaticAssert::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found static assert with no message}} 86 // [email protected]:* {{but in 'FirstModule' found static assert with message}} 87 #endif 88 89 #if defined(FIRST) 90 struct S3 { 91 static_assert(3 == 3, "Message"); 92 }; 93 #elif defined(SECOND) 94 struct S3 { 95 static_assert(3 != 4, "Message"); 96 }; 97 #else 98 S3 s3; 99 // [email protected]:* {{'StaticAssert::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found static assert with condition}} 100 // [email protected]:* {{but in 'FirstModule' found static assert with different condition}} 101 #endif 102 103 #if defined(FIRST) 104 struct S4 { 105 static_assert(4 == 4, "Message"); 106 }; 107 #elif defined(SECOND) 108 struct S4 { 109 public: 110 }; 111 #else 112 S4 s4; 113 // [email protected]:* {{'StaticAssert::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 114 // [email protected]:* {{but in 'FirstModule' found static assert}} 115 #endif 116 } 117 118 namespace Field { 119 #if defined(FIRST) 120 struct S1 { 121 int x; 122 private: 123 int y; 124 }; 125 #elif defined(SECOND) 126 struct S1 { 127 int x; 128 int y; 129 }; 130 #else 131 S1 s1; 132 // [email protected]:* {{'Field::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found field}} 133 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 134 #endif 135 136 #if defined(FIRST) 137 struct S2 { 138 int x; 139 int y; 140 }; 141 #elif defined(SECOND) 142 struct S2 { 143 int y; 144 int x; 145 }; 146 #else 147 S2 s2; 148 // [email protected]:* {{'Field::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'y'}} 149 // [email protected]:* {{but in 'FirstModule' found field 'x'}} 150 #endif 151 152 #if defined(FIRST) 153 struct S3 { 154 double x; 155 }; 156 #elif defined(SECOND) 157 struct S3 { 158 int x; 159 }; 160 #else 161 S3 s3; 162 // [email protected]:* {{'Field::S3::x' from module 'FirstModule' is not present in definition of 'Field::S3' in module 'SecondModule'}} 163 // [email protected]:* {{declaration of 'x' does not match}} 164 #endif 165 166 #if defined(FIRST) 167 typedef int A; 168 struct S4 { 169 A x; 170 }; 171 172 struct S5 { 173 A x; 174 }; 175 #elif defined(SECOND) 176 typedef int B; 177 struct S4 { 178 B x; 179 }; 180 181 struct S5 { 182 int x; 183 }; 184 #else 185 S4 s4; 186 // [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')}} 187 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'Field::A' (aka 'int')}} 188 189 S5 s5; 190 // [email protected]:* {{'Field::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'int'}} 191 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'Field::A' (aka 'int')}} 192 #endif 193 194 #if defined(FIRST) 195 struct S6 { 196 unsigned x; 197 }; 198 #elif defined(SECOND) 199 struct S6 { 200 unsigned x : 1; 201 }; 202 #else 203 S6 s6; 204 // [email protected]:* {{'Field::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found bitfield 'x'}} 205 // [email protected]:* {{but in 'FirstModule' found non-bitfield 'x'}} 206 #endif 207 208 #if defined(FIRST) 209 struct S7 { 210 unsigned x : 2; 211 }; 212 #elif defined(SECOND) 213 struct S7 { 214 unsigned x : 1; 215 }; 216 #else 217 S7 s7; 218 // [email protected]:* {{'Field::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found bitfield 'x' with one width expression}} 219 // [email protected]:* {{but in 'FirstModule' found bitfield 'x' with different width expression}} 220 #endif 221 222 #if defined(FIRST) 223 struct S8 { 224 unsigned x : 2; 225 }; 226 #elif defined(SECOND) 227 struct S8 { 228 unsigned x : 1 + 1; 229 }; 230 #else 231 S8 s8; 232 // [email protected]:* {{'Field::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found bitfield 'x' with one width expression}} 233 // [email protected]:* {{but in 'FirstModule' found bitfield 'x' with different width expression}} 234 #endif 235 236 #if defined(FIRST) 237 struct S9 { 238 mutable int x; 239 }; 240 #elif defined(SECOND) 241 struct S9 { 242 int x; 243 }; 244 #else 245 S9 s9; 246 // [email protected]:* {{'Field::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found non-mutable field 'x'}} 247 // [email protected]:* {{but in 'FirstModule' found mutable field 'x'}} 248 #endif 249 250 #if defined(FIRST) 251 struct S10 { 252 unsigned x = 5; 253 }; 254 #elif defined(SECOND) 255 struct S10 { 256 unsigned x; 257 }; 258 #else 259 S10 s10; 260 // [email protected]:* {{'Field::S10' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with no initalizer}} 261 // [email protected]:* {{but in 'FirstModule' found field 'x' with an initializer}} 262 #endif 263 264 #if defined(FIRST) 265 struct S11 { 266 unsigned x = 5; 267 }; 268 #elif defined(SECOND) 269 struct S11 { 270 unsigned x = 7; 271 }; 272 #else 273 S11 s11; 274 // [email protected]:* {{'Field::S11' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with an initializer}} 275 // [email protected]:* {{but in 'FirstModule' found field 'x' with a different initializer}} 276 #endif 277 278 #if defined(FIRST) 279 struct S12 { 280 unsigned x[5]; 281 }; 282 #elif defined(SECOND) 283 struct S12 { 284 unsigned x[7]; 285 }; 286 #else 287 S12 s12; 288 // [email protected]:* {{'Field::S12::x' from module 'FirstModule' is not present in definition of 'Field::S12' in module 'SecondModule'}} 289 // [email protected]:* {{declaration of 'x' does not match}} 290 #endif 291 292 #if defined(FIRST) 293 struct S13 { 294 unsigned x[7]; 295 }; 296 #elif defined(SECOND) 297 struct S13 { 298 double x[7]; 299 }; 300 #else 301 S13 s13; 302 // [email protected]:* {{'Field::S13::x' from module 'FirstModule' is not present in definition of 'Field::S13' in module 'SecondModule'}} 303 // [email protected]:* {{declaration of 'x' does not match}} 304 #endif 305 } // namespace Field 306 307 namespace Method { 308 #if defined(FIRST) 309 struct S1 { 310 void A() {} 311 }; 312 #elif defined(SECOND) 313 struct S1 { 314 private: 315 void A() {} 316 }; 317 #else 318 S1 s1; 319 // [email protected]:* {{'Method::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 320 // [email protected]:* {{but in 'FirstModule' found method}} 321 #endif 322 323 #if defined(FIRST) 324 struct S2 { 325 void A() {} 326 void B() {} 327 }; 328 #elif defined(SECOND) 329 struct S2 { 330 void B() {} 331 void A() {} 332 }; 333 #else 334 S2 s2; 335 // [email protected]:* {{'Method::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'B'}} 336 // [email protected]:* {{but in 'FirstModule' found method 'A'}} 337 #endif 338 339 #if defined(FIRST) 340 struct S3 { 341 static void A() {} 342 void A(int) {} 343 }; 344 #elif defined(SECOND) 345 struct S3 { 346 void A(int) {} 347 static void A() {} 348 }; 349 #else 350 S3 s3; 351 // [email protected]:* {{'Method::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not static}} 352 // [email protected]:* {{but in 'FirstModule' found method 'A' is static}} 353 #endif 354 355 #if defined(FIRST) 356 struct S4 { 357 virtual void A() {} 358 void B() {} 359 }; 360 #elif defined(SECOND) 361 struct S4 { 362 void A() {} 363 virtual void B() {} 364 }; 365 #else 366 S4 s4; 367 // [email protected]:* {{'Method::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not virtual}} 368 // [email protected]:* {{but in 'FirstModule' found method 'A' is virtual}} 369 #endif 370 371 #if defined(FIRST) 372 struct S5 { 373 virtual void A() = 0; 374 virtual void B() {}; 375 }; 376 #elif defined(SECOND) 377 struct S5 { 378 virtual void A() {} 379 virtual void B() = 0; 380 }; 381 #else 382 S5 *s5; 383 // [email protected]:* {{'Method::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is virtual}} 384 // [email protected]:* {{but in 'FirstModule' found method 'A' is pure virtual}} 385 #endif 386 387 #if defined(FIRST) 388 struct S6 { 389 inline void A() {} 390 }; 391 #elif defined(SECOND) 392 struct S6 { 393 void A() {} 394 }; 395 #else 396 S6 s6; 397 // [email protected]:* {{'Method::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not inline}} 398 // [email protected]:* {{but in 'FirstModule' found method 'A' is inline}} 399 #endif 400 401 #if defined(FIRST) 402 struct S7 { 403 void A() volatile {} 404 void A() {} 405 }; 406 #elif defined(SECOND) 407 struct S7 { 408 void A() {} 409 void A() volatile {} 410 }; 411 #else 412 S7 s7; 413 // [email protected]:* {{'Method::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not volatile}} 414 // [email protected]:* {{but in 'FirstModule' found method 'A' is volatile}} 415 #endif 416 417 #if defined(FIRST) 418 struct S8 { 419 void A() const {} 420 void A() {} 421 }; 422 #elif defined(SECOND) 423 struct S8 { 424 void A() {} 425 void A() const {} 426 }; 427 #else 428 S8 s8; 429 // [email protected]:* {{'Method::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' is not const}} 430 // [email protected]:* {{but in 'FirstModule' found method 'A' is const}} 431 #endif 432 433 #if defined(FIRST) 434 struct S9 { 435 void A(int x) {} 436 void A(int x, int y) {} 437 }; 438 #elif defined(SECOND) 439 struct S9 { 440 void A(int x, int y) {} 441 void A(int x) {} 442 }; 443 #else 444 S9 s9; 445 // [email protected]:* {{'Method::S9' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'A' that has 2 parameters}} 446 // [email protected]:* {{but in 'FirstModule' found method 'A' that has 1 parameter}} 447 #endif 448 449 #if defined(FIRST) 450 struct S10 { 451 void A(int x) {} 452 void A(float x) {} 453 }; 454 #elif defined(SECOND) 455 struct S10 { 456 void A(float x) {} 457 void A(int x) {} 458 }; 459 #else 460 S10 s10; 461 // [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'}} 462 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter of type 'int'}} 463 #endif 464 465 #if defined(FIRST) 466 struct S11 { 467 void A(int x) {} 468 }; 469 #elif defined(SECOND) 470 struct S11 { 471 void A(int y) {} 472 }; 473 #else 474 S11 s11; 475 // [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'}} 476 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter named 'x'}} 477 #endif 478 479 #if defined(FIRST) 480 struct S12 { 481 void A(int x) {} 482 }; 483 #elif defined(SECOND) 484 struct S12 { 485 void A(int x = 1) {} 486 }; 487 #else 488 S12 s12; 489 // [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}} 490 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter with a default argument}} 491 #endif 492 493 #if defined(FIRST) 494 struct S13 { 495 void A(int x = 1 + 0) {} 496 }; 497 #elif defined(SECOND) 498 struct S13 { 499 void A(int x = 1) {} 500 }; 501 #else 502 S13 s13; 503 // [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}} 504 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter with a different default argument}} 505 #endif 506 507 #if defined(FIRST) 508 struct S14 { 509 void A(int x[2]) {} 510 }; 511 #elif defined(SECOND) 512 struct S14 { 513 void A(int x[3]) {} 514 }; 515 #else 516 S14 s14; 517 // [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]'}} 518 // [email protected]:* {{but in 'FirstModule' found method 'A' with 1st parameter of type 'int *' decayed from 'int [2]'}} 519 #endif 520 } // namespace Method 521 522 // Naive parsing of AST can lead to cycles in processing. Ensure 523 // self-references don't trigger an endless cycles of AST node processing. 524 namespace SelfReference { 525 #if defined(FIRST) 526 template <template <int> class T> class Wrapper {}; 527 528 template <int N> class S { 529 S(Wrapper<::SelfReference::S> &Ref) {} 530 }; 531 532 struct Xx { 533 struct Yy { 534 }; 535 }; 536 537 Xx::Xx::Xx::Yy yy; 538 539 namespace NNS { 540 template <typename> struct Foo; 541 template <template <class> class T = NNS::Foo> 542 struct NestedNamespaceSpecifier {}; 543 } 544 #endif 545 } // namespace SelfReference 546 547 namespace TypeDef { 548 #if defined(FIRST) 549 struct S1 { 550 typedef int a; 551 }; 552 #elif defined(SECOND) 553 struct S1 { 554 typedef double a; 555 }; 556 #else 557 S1 s1; 558 // [email protected]:* {{'TypeDef::S1::a' from module 'FirstModule' is not present in definition of 'TypeDef::S1' in module 'SecondModule'}} 559 // [email protected]:* {{declaration of 'a' does not match}} 560 #endif 561 562 #if defined(FIRST) 563 struct S2 { 564 typedef int a; 565 }; 566 #elif defined(SECOND) 567 struct S2 { 568 typedef int b; 569 }; 570 #else 571 S2 s2; 572 // [email protected]:* {{'TypeDef::S2::a' from module 'FirstModule' is not present in definition of 'TypeDef::S2' in module 'SecondModule'}} 573 // [email protected]:* {{definition has no member 'a'}} 574 #endif 575 576 #if defined(FIRST) 577 typedef int T; 578 struct S3 { 579 typedef T a; 580 }; 581 #elif defined(SECOND) 582 typedef double T; 583 struct S3 { 584 typedef T a; 585 }; 586 #else 587 S3 s3; 588 // [email protected]:* {{'TypeDef::S3::a' from module 'FirstModule' is not present in definition of 'TypeDef::S3' in module 'SecondModule'}} 589 // [email protected]:* {{declaration of 'a' does not match}} 590 #endif 591 592 #if defined(FIRST) 593 struct S4 { 594 typedef int a; 595 typedef int b; 596 }; 597 #elif defined(SECOND) 598 struct S4 { 599 typedef int b; 600 typedef int a; 601 }; 602 #else 603 S4 s4; 604 // [email protected]:* {{'TypeDef::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found typedef name 'b'}} 605 // [email protected]:* {{but in 'FirstModule' found typedef name 'a'}} 606 #endif 607 608 #if defined(FIRST) 609 struct S5 { 610 typedef int a; 611 typedef int b; 612 int x; 613 }; 614 #elif defined(SECOND) 615 struct S5 { 616 int x; 617 typedef int b; 618 typedef int a; 619 }; 620 #else 621 S5 s5; 622 // [email protected]:* {{'TypeDef::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field}} 623 // [email protected]:* {{but in 'FirstModule' found typedef}} 624 #endif 625 626 #if defined(FIRST) 627 typedef float F; 628 struct S6 { 629 typedef int a; 630 typedef F b; 631 }; 632 #elif defined(SECOND) 633 struct S6 { 634 typedef int a; 635 typedef float b; 636 }; 637 #else 638 S6 s6; 639 // [email protected]:* {{'TypeDef::S6' has different definitions in different modules; first difference is definition in module 'SecondModule' found typedef 'b' with underlying type 'float'}} 640 // [email protected]:* {{but in 'FirstModule' found typedef 'b' with different underlying type 'TypeDef::F' (aka 'float')}} 641 #endif 642 } // namespace TypeDef 643 644 namespace Using { 645 #if defined(FIRST) 646 struct S1 { 647 using a = int; 648 }; 649 #elif defined(SECOND) 650 struct S1 { 651 using a = double; 652 }; 653 #else 654 S1 s1; 655 // [email protected]:* {{'Using::S1::a' from module 'FirstModule' is not present in definition of 'Using::S1' in module 'SecondModule'}} 656 // [email protected]:* {{declaration of 'a' does not match}} 657 #endif 658 659 #if defined(FIRST) 660 struct S2 { 661 using a = int; 662 }; 663 #elif defined(SECOND) 664 struct S2 { 665 using b = int; 666 }; 667 #else 668 S2 s2; 669 // [email protected]:* {{'Using::S2::a' from module 'FirstModule' is not present in definition of 'Using::S2' in module 'SecondModule'}} 670 // [email protected]:* {{definition has no member 'a'}} 671 #endif 672 673 #if defined(FIRST) 674 typedef int T; 675 struct S3 { 676 using a = T; 677 }; 678 #elif defined(SECOND) 679 typedef double T; 680 struct S3 { 681 using a = T; 682 }; 683 #else 684 S3 s3; 685 // [email protected]:* {{'Using::S3::a' from module 'FirstModule' is not present in definition of 'Using::S3' in module 'SecondModule'}} 686 // [email protected]:* {{declaration of 'a' does not match}} 687 #endif 688 689 #if defined(FIRST) 690 struct S4 { 691 using a = int; 692 using b = int; 693 }; 694 #elif defined(SECOND) 695 struct S4 { 696 using b = int; 697 using a = int; 698 }; 699 #else 700 S4 s4; 701 // [email protected]:* {{'Using::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found type alias name 'b'}} 702 // [email protected]:* {{but in 'FirstModule' found type alias name 'a'}} 703 #endif 704 705 #if defined(FIRST) 706 struct S5 { 707 using a = int; 708 using b = int; 709 int x; 710 }; 711 #elif defined(SECOND) 712 struct S5 { 713 int x; 714 using b = int; 715 using a = int; 716 }; 717 #else 718 S5 s5; 719 // [email protected]:* {{'Using::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found field}} 720 // [email protected]:* {{but in 'FirstModule' found type alias}} 721 #endif 722 723 #if defined(FIRST) 724 typedef float F; 725 struct S6 { 726 using a = int; 727 using b = F; 728 }; 729 #elif defined(SECOND) 730 struct S6 { 731 using a = int; 732 using b = float; 733 }; 734 #else 735 S6 s6; 736 // [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'}} 737 // [email protected]:* {{but in 'FirstModule' found type alias 'b' with different underlying type 'Using::F' (aka 'float')}} 738 #endif 739 } // namespace Using 740 741 namespace RecordType { 742 #if defined(FIRST) 743 struct B1 {}; 744 struct S1 { 745 B1 x; 746 }; 747 #elif defined(SECOND) 748 struct A1 {}; 749 struct S1 { 750 A1 x; 751 }; 752 #else 753 S1 s1; 754 // [email protected]:* {{'RecordType::S1::x' from module 'FirstModule' is not present in definition of 'RecordType::S1' in module 'SecondModule'}} 755 // [email protected]:* {{declaration of 'x' does not match}} 756 #endif 757 } 758 759 namespace DependentType { 760 #if defined(FIRST) 761 template <class T> 762 class S1 { 763 typename T::typeA x; 764 }; 765 #elif defined(SECOND) 766 template <class T> 767 class S1 { 768 typename T::typeB x; 769 }; 770 #else 771 template<class T> 772 using U1 = S1<T>; 773 // [email protected]:* {{'DependentType::S1::x' from module 'FirstModule' is not present in definition of 'S1<T>' in module 'SecondModule'}} 774 // [email protected]:* {{declaration of 'x' does not match}} 775 #endif 776 } 777 778 namespace ElaboratedType { 779 #if defined(FIRST) 780 namespace N1 { using type = double; } 781 struct S1 { 782 N1::type x; 783 }; 784 #elif defined(SECOND) 785 namespace N1 { using type = int; } 786 struct S1 { 787 N1::type x; 788 }; 789 #else 790 S1 s1; 791 // [email protected]:* {{'ElaboratedType::S1::x' from module 'FirstModule' is not present in definition of 'ElaboratedType::S1' in module 'SecondModule'}} 792 // [email protected]:* {{declaration of 'x' does not match}} 793 #endif 794 } 795 796 namespace Enum { 797 #if defined(FIRST) 798 enum A1 {}; 799 struct S1 { 800 A1 x; 801 }; 802 #elif defined(SECOND) 803 enum A2 {}; 804 struct S1 { 805 A2 x; 806 }; 807 #else 808 S1 s1; 809 // [email protected]:* {{'Enum::S1::x' from module 'FirstModule' is not present in definition of 'Enum::S1' in module 'SecondModule'}} 810 // [email protected]:* {{declaration of 'x' does not match}} 811 #endif 812 } 813 814 namespace NestedNamespaceSpecifier { 815 #if defined(FIRST) 816 namespace LevelA1 { 817 using Type = int; 818 } 819 820 struct S1 { 821 LevelA1::Type x; 822 }; 823 # elif defined(SECOND) 824 namespace LevelB1 { 825 namespace LevelC1 { 826 using Type = int; 827 } 828 } 829 830 struct S1 { 831 LevelB1::LevelC1::Type x; 832 }; 833 #else 834 S1 s1; 835 // [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')}} 836 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'LevelA1::Type' (aka 'int')}} 837 #endif 838 839 #if defined(FIRST) 840 namespace LevelA2 { using Type = int; } 841 struct S2 { 842 LevelA2::Type x; 843 }; 844 # elif defined(SECOND) 845 struct S2 { 846 int x; 847 }; 848 #else 849 S2 s2; 850 // [email protected]:* {{'NestedNamespaceSpecifier::S2' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with type 'int'}} 851 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'LevelA2::Type' (aka 'int')}} 852 #endif 853 854 namespace LevelA3 { using Type = int; } 855 namespace LevelB3 { using Type = int; } 856 #if defined(FIRST) 857 struct S3 { 858 LevelA3::Type x; 859 }; 860 # elif defined(SECOND) 861 struct S3 { 862 LevelB3::Type x; 863 }; 864 #else 865 S3 s3; 866 // [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')}} 867 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'LevelA3::Type' (aka 'int')}} 868 #endif 869 870 #if defined(FIRST) 871 struct TA4 { using Type = int; }; 872 struct S4 { 873 TA4::Type x; 874 }; 875 # elif defined(SECOND) 876 struct TB4 { using Type = int; }; 877 struct S4 { 878 TB4::Type x; 879 }; 880 #else 881 S4 s4; 882 // [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')}} 883 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'TA4::Type' (aka 'int')}} 884 #endif 885 886 #if defined(FIRST) 887 struct T5 { using Type = int; }; 888 struct S5 { 889 T5::Type x; 890 }; 891 # elif defined(SECOND) 892 namespace T5 { using Type = int; }; 893 struct S5 { 894 T5::Type x; 895 }; 896 #else 897 S5 s5; 898 // [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')}} 899 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'T5::Type' (aka 'int')}} 900 #endif 901 902 #if defined(FIRST) 903 namespace N6 {using I = int;} 904 struct S6 { 905 NestedNamespaceSpecifier::N6::I x; 906 }; 907 # elif defined(SECOND) 908 using I = int; 909 struct S6 { 910 ::NestedNamespaceSpecifier::I x; 911 }; 912 #else 913 S6 s6; 914 // [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')}} 915 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'NestedNamespaceSpecifier::N6::I' (aka 'int')}} 916 #endif 917 918 #if defined(FIRST) 919 template <class T, class U> 920 class S7 { 921 typename T::type *x = {}; 922 int z = x->T::foo(); 923 }; 924 #elif defined(SECOND) 925 template <class T, class U> 926 class S7 { 927 typename T::type *x = {}; 928 int z = x->U::foo(); 929 }; 930 #else 931 template <class T, class U> 932 using U7 = S7<T, U>; 933 // [email protected]:* {{'NestedNamespaceSpecifier::S7' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'z' with an initializer}} 934 // [email protected]:* {{but in 'FirstModule' found field 'z' with a different initializer}} 935 #endif 936 937 #if defined(FIRST) 938 template <class T> 939 class S8 { 940 int x = T::template X<int>::value; 941 }; 942 #elif defined(SECOND) 943 template <class T> 944 class S8 { 945 int x = T::template Y<int>::value; 946 }; 947 #else 948 template <class T> 949 using U8 = S8<T>; 950 // [email protected]:* {{'NestedNamespaceSpecifier::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found field 'x' with an initializer}} 951 // [email protected]:* {{but in 'FirstModule' found field 'x' with a different initializer}} 952 #endif 953 954 #if defined(FIRST) 955 namespace N9 { using I = int; } 956 namespace O9 = N9; 957 struct S9 { 958 O9::I x; 959 }; 960 #elif defined(SECOND) 961 namespace N9 { using I = int; } 962 namespace P9 = N9; 963 struct S9 { 964 P9::I x; 965 }; 966 #else 967 S9 s9; 968 // [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')}} 969 // [email protected]:* {{but in 'FirstModule' found field 'x' with type 'O9::I' (aka 'int')}} 970 #endif 971 } 972 973 namespace TemplateSpecializationType { 974 #if defined(FIRST) 975 template <class T1> struct U1 {}; 976 struct S1 { 977 U1<int> u; 978 }; 979 #elif defined(SECOND) 980 template <class T1, class T2> struct U1 {}; 981 struct S1 { 982 U1<int, int> u; 983 }; 984 #else 985 S1 s1; 986 // [email protected]:* {{'TemplateSpecializationType::S1::u' from module 'FirstModule' is not present in definition of 'TemplateSpecializationType::S1' in module 'SecondModule'}} 987 // [email protected]:* {{declaration of 'u' does not match}} 988 #endif 989 990 #if defined(FIRST) 991 template <class T1> struct U2 {}; 992 struct S2 { 993 U2<int> u; 994 }; 995 #elif defined(SECOND) 996 template <class T1> struct V1 {}; 997 struct S2 { 998 V1<int> u; 999 }; 1000 #else 1001 S2 s2; 1002 // [email protected]:* {{'TemplateSpecializationType::S2::u' from module 'FirstModule' is not present in definition of 'TemplateSpecializationType::S2' in module 'SecondModule'}} 1003 // [email protected]:* {{declaration of 'u' does not match}} 1004 #endif 1005 } 1006 1007 namespace TemplateArgument { 1008 #if defined(FIRST) 1009 template <class> struct U1{}; 1010 struct S1 { 1011 U1<int> x; 1012 }; 1013 #elif defined(SECOND) 1014 template <int> struct U1{}; 1015 struct S1 { 1016 U1<1> x; 1017 }; 1018 #else 1019 S1 s1; 1020 // [email protected]:* {{'TemplateArgument::S1::x' from module 'FirstModule' is not present in definition of 'TemplateArgument::S1' in module 'SecondModule'}} 1021 // [email protected]:* {{declaration of 'x' does not match}} 1022 #endif 1023 1024 #if defined(FIRST) 1025 template <int> struct U2{}; 1026 struct S2 { 1027 using T = U2<2>; 1028 }; 1029 #elif defined(SECOND) 1030 template <int> struct U2{}; 1031 struct S2 { 1032 using T = U2<(2)>; 1033 }; 1034 #else 1035 S2 s2; 1036 // [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)>'}} 1037 // [email protected]:* {{but in 'FirstModule' found type alias 'T' with different underlying type 'U2<2>'}} 1038 #endif 1039 1040 #if defined(FIRST) 1041 template <int> struct U3{}; 1042 struct S3 { 1043 using T = U3<2>; 1044 }; 1045 #elif defined(SECOND) 1046 template <int> struct U3{}; 1047 struct S3 { 1048 using T = U3<1 + 1>; 1049 }; 1050 #else 1051 S3 s3; 1052 // [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>'}} 1053 // [email protected]:* {{but in 'FirstModule' found type alias 'T' with different underlying type 'U3<2>'}} 1054 #endif 1055 1056 #if defined(FIRST) 1057 template<class> struct T4a {}; 1058 template <template <class> class T> struct U4 {}; 1059 struct S4 { 1060 U4<T4a> x; 1061 }; 1062 #elif defined(SECOND) 1063 template<class> struct T4b {}; 1064 template <template <class> class T> struct U4 {}; 1065 struct S4 { 1066 U4<T4b> x; 1067 }; 1068 #else 1069 S4 s4; 1070 // [email protected]:* {{'TemplateArgument::S4::x' from module 'FirstModule' is not present in definition of 'TemplateArgument::S4' in module 'SecondModule'}} 1071 // [email protected]:* {{declaration of 'x' does not match}} 1072 #endif 1073 } 1074 1075 namespace TemplateTypeParmType { 1076 #if defined(FIRST) 1077 template <class T1, class T2> 1078 struct S1 { 1079 T1 x; 1080 }; 1081 #elif defined(SECOND) 1082 template <class T1, class T2> 1083 struct S1 { 1084 T2 x; 1085 }; 1086 #else 1087 using TemplateTypeParmType::S1; 1088 // [email protected]:* {{'TemplateTypeParmType::S1::x' from module 'FirstModule' is not present in definition of 'S1<T1, T2>' in module 'SecondModule'}} 1089 // [email protected]:* {{declaration of 'x' does not match}} 1090 #endif 1091 1092 #if defined(FIRST) 1093 template <int ...Ts> 1094 struct U2 {}; 1095 template <int T, int U> 1096 class S2 { 1097 typedef U2<U, T> type; 1098 type x; 1099 }; 1100 #elif defined(SECOND) 1101 template <int ...Ts> 1102 struct U2 {}; 1103 template <int T, int U> 1104 class S2 { 1105 typedef U2<T, U> type; 1106 type x; 1107 }; 1108 #else 1109 using TemplateTypeParmType::S2; 1110 // [email protected]:* {{'TemplateTypeParmType::S2::x' from module 'FirstModule' is not present in definition of 'S2<T, U>' in module 'SecondModule'}} 1111 // [email protected]:* {{declaration of 'x' does not match}} 1112 // [email protected]:* {{'TemplateTypeParmType::S2::type' from module 'FirstModule' is not present in definition of 'S2<T, U>' in module 'SecondModule'}} 1113 // [email protected]:* {{declaration of 'type' does not match}} 1114 #endif 1115 } 1116 1117 namespace VarDecl { 1118 #if defined(FIRST) 1119 struct S1 { 1120 static int x; 1121 static int y; 1122 }; 1123 #elif defined(SECOND) 1124 struct S1 { 1125 static int y; 1126 static int x; 1127 }; 1128 #else 1129 S1 s1; 1130 // [email protected]:* {{'VarDecl::S1' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member with name 'y'}} 1131 // [email protected]:* {{but in 'FirstModule' found data member with name 'x'}} 1132 #endif 1133 1134 #if defined(FIRST) 1135 struct S2 { 1136 static int x; 1137 }; 1138 #elif defined(SECOND) 1139 using I = int; 1140 struct S2 { 1141 static I x; 1142 }; 1143 #else 1144 S2 s2; 1145 // [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')}} 1146 // [email protected]:* {{but in 'FirstModule' found data member 'x' with different type 'int'}} 1147 #endif 1148 1149 #if defined(FIRST) 1150 struct S3 { 1151 static const int x = 1; 1152 }; 1153 #elif defined(SECOND) 1154 struct S3 { 1155 static const int x; 1156 }; 1157 #else 1158 S3 s3; 1159 // [email protected]:* {{'VarDecl::S3' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' with an initializer}} 1160 // [email protected]:* {{but in 'FirstModule' found data member 'x' without an initializer}} 1161 #endif 1162 1163 #if defined(FIRST) 1164 struct S4 { 1165 static const int x = 1; 1166 }; 1167 #elif defined(SECOND) 1168 struct S4 { 1169 static const int x = 2; 1170 }; 1171 #else 1172 S4 s4; 1173 // [email protected]:* {{'VarDecl::S4' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' with an initializer}} 1174 // [email protected]:* {{but in 'FirstModule' found data member 'x' with a different initializer}} 1175 #endif 1176 1177 #if defined(FIRST) 1178 struct S5 { 1179 static const int x = 1; 1180 }; 1181 #elif defined(SECOND) 1182 struct S5 { 1183 static constexpr int x = 1; 1184 }; 1185 #else 1186 S5 s5; 1187 // [email protected]:* {{'VarDecl::S5' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member 'x' is not constexpr}} 1188 // [email protected]:* {{but in 'FirstModule' found data member 'x' is constexpr}} 1189 #endif 1190 1191 #if defined(FIRST) 1192 struct S6 { 1193 static const int x = 1; 1194 }; 1195 #elif defined(SECOND) 1196 struct S6 { 1197 static const int y = 1; 1198 }; 1199 #else 1200 S6 s6; 1201 // [email protected]:* {{'VarDecl::S6::x' from module 'FirstModule' is not present in definition of 'VarDecl::S6' in module 'SecondModule'}} 1202 // [email protected]:* {{definition has no member 'x'}} 1203 #endif 1204 1205 #if defined(FIRST) 1206 struct S7 { 1207 static const int x = 1; 1208 }; 1209 #elif defined(SECOND) 1210 struct S7 { 1211 static const unsigned x = 1; 1212 }; 1213 #else 1214 S7 s7; 1215 // [email protected]:* {{'VarDecl::S7::x' from module 'FirstModule' is not present in definition of 'VarDecl::S7' in module 'SecondModule'}} 1216 // [email protected]:* {{declaration of 'x' does not match}} 1217 #endif 1218 1219 #if defined(FIRST) 1220 struct S8 { 1221 public: 1222 static const int x = 1; 1223 }; 1224 #elif defined(SECOND) 1225 struct S8 { 1226 static const int x = 1; 1227 public: 1228 }; 1229 #else 1230 S8 s8; 1231 // [email protected]:* {{'VarDecl::S8' has different definitions in different modules; first difference is definition in module 'SecondModule' found data member}} 1232 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1233 #endif 1234 1235 #if defined(FIRST) 1236 struct S9 { 1237 static const int x = 1; 1238 }; 1239 #elif defined(SECOND) 1240 struct S9 { 1241 static int x; 1242 }; 1243 #else 1244 S9 s9; 1245 // [email protected]:* {{'VarDecl::S9::x' from module 'FirstModule' is not present in definition of 'VarDecl::S9' in module 'SecondModule'}} 1246 // [email protected]:* {{declaration of 'x' does not match}} 1247 #endif 1248 1249 #if defined(FIRST) 1250 template <typename T> 1251 struct S { 1252 struct R { 1253 void foo(T x = 0) {} 1254 }; 1255 }; 1256 #elif defined(SECOND) 1257 template <typename T> 1258 struct S { 1259 struct R { 1260 void foo(T x = 1) {} 1261 }; 1262 }; 1263 #else 1264 void run() { 1265 S<int>::R().foo(); 1266 } 1267 // [email protected]:* {{'VarDecl::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}} 1268 // [email protected]:* {{but in 'FirstModule' found method 'foo' with 1st parameter with a different default argument}} 1269 #endif 1270 1271 #if defined(FIRST) 1272 template <typename alpha> struct Bravo { 1273 void charlie(bool delta = false) {} 1274 }; 1275 typedef Bravo<char> echo; 1276 echo foxtrot; 1277 #elif defined(SECOND) 1278 template <typename alpha> struct Bravo { 1279 void charlie(bool delta = (false)) {} 1280 }; 1281 typedef Bravo<char> echo; 1282 echo foxtrot; 1283 #else 1284 Bravo<char> golf; 1285 // [email protected]:* {{'VarDecl::Bravo' has different definitions in different modules; first difference is definition in module 'SecondModule' found method 'charlie' with 1st parameter with a default argument}} 1286 // [email protected]:* {{but in 'FirstModule' found method 'charlie' with 1st parameter with a different default argument}} 1287 #endif 1288 } 1289 1290 // Interesting cases that should not cause errors. struct S should not error 1291 // while struct T should error at the access specifier mismatch at the end. 1292 namespace AllDecls { 1293 #define CREATE_ALL_DECL_STRUCT(NAME, ACCESS) \ 1294 typedef int INT; \ 1295 struct NAME { \ 1296 public: \ 1297 private: \ 1298 protected: \ 1299 static_assert(1 == 1, "Message"); \ 1300 static_assert(2 == 2); \ 1301 \ 1302 int x; \ 1303 double y; \ 1304 \ 1305 INT z; \ 1306 \ 1307 unsigned a : 1; \ 1308 unsigned b : 2 * 2 + 5 / 2; \ 1309 \ 1310 mutable int c = sizeof(x + y); \ 1311 \ 1312 void method() {} \ 1313 static void static_method() {} \ 1314 virtual void virtual_method() {} \ 1315 virtual void pure_virtual_method() = 0; \ 1316 inline void inline_method() {} \ 1317 void volatile_method() volatile {} \ 1318 void const_method() const {} \ 1319 \ 1320 typedef int typedef_int; \ 1321 using using_int = int; \ 1322 \ 1323 void method_one_arg(int x) {} \ 1324 void method_one_arg_default_argument(int x = 5 + 5) {} \ 1325 void method_decayed_type(int x[5]) {} \ 1326 \ 1327 int constant_arr[5]; \ 1328 \ 1329 ACCESS: \ 1330 }; 1331 1332 #if defined(FIRST) 1333 CREATE_ALL_DECL_STRUCT(S, public) 1334 #elif defined(SECOND) 1335 CREATE_ALL_DECL_STRUCT(S, public) 1336 #else 1337 S *s; 1338 #endif 1339 1340 #if defined(FIRST) 1341 CREATE_ALL_DECL_STRUCT(T, private) 1342 #elif defined(SECOND) 1343 CREATE_ALL_DECL_STRUCT(T, public) 1344 #else 1345 T *t; 1346 // [email protected]:* {{'AllDecls::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 1347 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 1348 #endif 1349 } 1350 1351 namespace FriendFunction { 1352 #if defined(FIRST) 1353 void F(int = 0); 1354 struct S { friend void F(int); }; 1355 #elif defined(SECOND) 1356 void F(int); 1357 struct S { friend void F(int); }; 1358 #else 1359 S s; 1360 #endif 1361 1362 #if defined(FIRST) 1363 void G(int = 0); 1364 struct T { 1365 friend void G(int); 1366 1367 private: 1368 }; 1369 #elif defined(SECOND) 1370 void G(int); 1371 struct T { 1372 friend void G(int); 1373 1374 public: 1375 }; 1376 #else 1377 T t; 1378 // [email protected]:* {{'FriendFunction::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 1379 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 1380 #endif 1381 } // namespace FriendFunction 1382 1383 namespace ImplicitDecl { 1384 #if defined(FIRST) 1385 struct S { }; 1386 void S_Constructors() { 1387 // Trigger creation of implicit contructors 1388 S foo; 1389 S bar = foo; 1390 S baz(bar); 1391 } 1392 #elif defined(SECOND) 1393 struct S { }; 1394 #else 1395 S s; 1396 #endif 1397 1398 #if defined(FIRST) 1399 struct T { 1400 private: 1401 }; 1402 void T_Constructors() { 1403 // Trigger creation of implicit contructors 1404 T foo; 1405 T bar = foo; 1406 T baz(bar); 1407 } 1408 #elif defined(SECOND) 1409 struct T { 1410 public: 1411 }; 1412 #else 1413 T t; 1414 // [email protected]:* {{'ImplicitDecl::T' has different definitions in different modules; first difference is definition in module 'FirstModule' found private access specifier}} 1415 // [email protected]:* {{but in 'SecondModule' found public access specifier}} 1416 #endif 1417 1418 } // namespace ImplicitDelc 1419 1420 namespace TemplatedClass { 1421 #if defined(FIRST) 1422 template <class> 1423 struct S {}; 1424 #elif defined(SECOND) 1425 template <class> 1426 struct S {}; 1427 #else 1428 S<int> s; 1429 #endif 1430 1431 #if defined(FIRST) 1432 template <class> 1433 struct T { 1434 private: 1435 }; 1436 #elif defined(SECOND) 1437 template <class> 1438 struct T { 1439 public: 1440 }; 1441 #else 1442 T<int> t; 1443 // [email protected]:* {{'TemplatedClass::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 1444 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 1445 #endif 1446 } // namespace TemplatedClass 1447 1448 namespace TemplateClassWithField { 1449 #if defined(FIRST) 1450 template <class A> 1451 struct S { 1452 A a; 1453 }; 1454 #elif defined(SECOND) 1455 template <class A> 1456 struct S { 1457 A a; 1458 }; 1459 #else 1460 S<int> s; 1461 #endif 1462 1463 #if defined(FIRST) 1464 template <class A> 1465 struct T { 1466 A a; 1467 1468 private: 1469 }; 1470 #elif defined(SECOND) 1471 template <class A> 1472 struct T { 1473 A a; 1474 1475 public: 1476 }; 1477 #else 1478 T<int> t; 1479 // [email protected]:* {{'TemplateClassWithField::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found public access specifier}} 1480 // [email protected]:* {{but in 'FirstModule' found private access specifier}} 1481 #endif 1482 } // namespace TemplateClassWithField 1483 1484 namespace TemplateClassWithTemplateField { 1485 #if defined(FIRST) 1486 template <class A> 1487 class WrapperS; 1488 template <class A> 1489 struct S { 1490 WrapperS<A> a; 1491 }; 1492 #elif defined(SECOND) 1493 template <class A> 1494 class WrapperS; 1495 template <class A> 1496 struct S { 1497 WrapperS<A> a; 1498 }; 1499 #else 1500 template <class A> 1501 class WrapperS{}; 1502 S<int> s; 1503 #endif 1504 1505 #if defined(FIRST) 1506 template <class A> 1507 class WrapperT; 1508 template <class A> 1509 struct T { 1510 WrapperT<A> a; 1511 1512 public: 1513 }; 1514 #elif defined(SECOND) 1515 template <class A> 1516 class WrapperT; 1517 template <class A> 1518 struct T { 1519 WrapperT<A> a; 1520 1521 private: 1522 }; 1523 #else 1524 template <class A> 1525 class WrapperT{}; 1526 T<int> t; 1527 // [email protected]:* {{'TemplateClassWithTemplateField::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1528 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1529 #endif 1530 } // namespace TemplateClassWithTemplateField 1531 1532 namespace EnumWithForwardDeclaration { 1533 #if defined(FIRST) 1534 enum E : int; 1535 struct S { 1536 void get(E) {} 1537 }; 1538 #elif defined(SECOND) 1539 enum E : int { A, B }; 1540 struct S { 1541 void get(E) {} 1542 }; 1543 #else 1544 S s; 1545 #endif 1546 1547 #if defined(FIRST) 1548 struct T { 1549 void get(E) {} 1550 public: 1551 }; 1552 #elif defined(SECOND) 1553 struct T { 1554 void get(E) {} 1555 private: 1556 }; 1557 #else 1558 T t; 1559 // [email protected]:* {{'EnumWithForwardDeclaration::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1560 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1561 #endif 1562 } // namespace EnumWithForwardDeclaration 1563 1564 namespace StructWithForwardDeclaration { 1565 #if defined(FIRST) 1566 struct P {}; 1567 struct S { 1568 struct P *ptr; 1569 }; 1570 #elif defined(SECOND) 1571 struct S { 1572 struct P *ptr; 1573 }; 1574 #else 1575 S s; 1576 #endif 1577 1578 #if defined(FIRST) 1579 struct Q {}; 1580 struct T { 1581 struct Q *ptr; 1582 public: 1583 }; 1584 #elif defined(SECOND) 1585 struct T { 1586 struct Q *ptr; 1587 private: 1588 }; 1589 #else 1590 T t; 1591 // [email protected]:* {{'StructWithForwardDeclaration::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1592 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1593 #endif 1594 } // namespace StructWithForwardDeclaration 1595 1596 namespace StructWithForwardDeclarationNoDefinition { 1597 #if defined(FIRST) 1598 struct P; 1599 struct S { 1600 struct P *ptr; 1601 }; 1602 #elif defined(SECOND) 1603 struct S { 1604 struct P *ptr; 1605 }; 1606 #else 1607 S s; 1608 #endif 1609 1610 #if defined(FIRST) 1611 struct Q; 1612 struct T { 1613 struct Q *ptr; 1614 1615 public: 1616 }; 1617 #elif defined(SECOND) 1618 struct T { 1619 struct Q *ptr; 1620 1621 private: 1622 }; 1623 #else 1624 T t; 1625 // [email protected]:* {{'StructWithForwardDeclarationNoDefinition::T' has different definitions in different modules; first difference is definition in module 'SecondModule' found private access specifier}} 1626 // [email protected]:* {{but in 'FirstModule' found public access specifier}} 1627 #endif 1628 } // namespace StructWithForwardDeclarationNoDefinition 1629 1630 namespace LateParsedDefaultArgument { 1631 #if defined(FIRST) 1632 template <typename T> 1633 struct S { 1634 struct R { 1635 void foo(T x = 0) {} 1636 }; 1637 }; 1638 #elif defined(SECOND) 1639 #else 1640 void run() { 1641 S<int>::R().foo(); 1642 } 1643 #endif 1644 } 1645 1646 namespace LateParsedDefaultArgument { 1647 #if defined(FIRST) 1648 template <typename alpha> struct Bravo { 1649 void charlie(bool delta = false) {} 1650 }; 1651 typedef Bravo<char> echo; 1652 echo foxtrot; 1653 1654 Bravo<char> golf; 1655 #elif defined(SECOND) 1656 #else 1657 #endif 1658 } 1659 1660 namespace DifferentParameterNameInTemplate { 1661 #if defined(FIRST) || defined(SECOND) 1662 template <typename T> 1663 struct S { 1664 typedef T Type; 1665 1666 static void Run(const Type *name_one); 1667 }; 1668 1669 template <typename T> 1670 void S<T>::Run(const T *name_two) {} 1671 1672 template <typename T> 1673 struct Foo { 1674 ~Foo() { Handler::Run(nullptr); } 1675 Foo() {} 1676 1677 class Handler : public S<T> {}; 1678 1679 void Get(typename Handler::Type *x = nullptr) {} 1680 void Add() { Handler::Run(nullptr); } 1681 }; 1682 #endif 1683 1684 #if defined(FIRST) 1685 struct Beta; 1686 1687 struct Alpha { 1688 Alpha(); 1689 void Go() { betas.Get(); } 1690 Foo<Beta> betas; 1691 }; 1692 1693 #elif defined(SECOND) 1694 struct Beta {}; 1695 1696 struct BetaHelper { 1697 void add_Beta() { betas.Add(); } 1698 Foo<Beta> betas; 1699 }; 1700 1701 #else 1702 Alpha::Alpha() {} 1703 #endif 1704 } 1705 1706 namespace ParameterTest { 1707 #if defined(FIRST) 1708 class X {}; 1709 template <typename G> 1710 class S { 1711 public: 1712 typedef G Type; 1713 static inline G *Foo(const G *a, int * = nullptr); 1714 }; 1715 1716 template<typename G> 1717 G* S<G>::Foo(const G* aaaa, int*) {} 1718 #elif defined(SECOND) 1719 template <typename G> 1720 class S { 1721 public: 1722 typedef G Type; 1723 static inline G *Foo(const G *a, int * = nullptr); 1724 }; 1725 1726 template<typename G> 1727 G* S<G>::Foo(const G* asdf, int*) {} 1728 #else 1729 S<X> s; 1730 #endif 1731 } 1732 1733 namespace MultipleTypedefs { 1734 #if defined(FIRST) 1735 typedef int B1; 1736 typedef B1 A1; 1737 struct S1 { 1738 A1 x; 1739 }; 1740 #elif defined(SECOND) 1741 typedef int A1; 1742 struct S1 { 1743 A1 x; 1744 }; 1745 #else 1746 S1 s1; 1747 #endif 1748 1749 #if defined(FIRST) 1750 struct T2 { int x; }; 1751 typedef T2 B2; 1752 typedef B2 A2; 1753 struct S2 { 1754 T2 x; 1755 }; 1756 #elif defined(SECOND) 1757 struct T2 { int x; }; 1758 typedef T2 A2; 1759 struct S2 { 1760 T2 x; 1761 }; 1762 #else 1763 S2 s2; 1764 #endif 1765 } 1766 1767 // Keep macros contained to one file. 1768 #ifdef FIRST 1769 #undef FIRST 1770 #endif 1771 #ifdef SECOND 1772 #undef SECOND 1773 #endif 1774