diff options
Diffstat (limited to 'test/CXX')
38 files changed, 709 insertions, 86 deletions
diff --git a/test/CXX/basic/basic.link/p8.cpp b/test/CXX/basic/basic.link/p8.cpp new file mode 100644 index 000000000000..54b977d77f68 --- /dev/null +++ b/test/CXX/basic/basic.link/p8.cpp @@ -0,0 +1,78 @@ +// RUN: %clang_cc1 -std=c++2a -verify %s -pedantic + +template<typename T> struct Template {}; + +struct Linkage1 { struct Inner {}; }; +typedef struct { struct Inner {}; } Linkage2; + +typedef struct {} const NoLinkage1; +auto x = [] {}; +typedef decltype(x) NoLinkage2; +auto f() { return [] {}; } +typedef decltype(f()) NoLinkage3; + +inline auto g() { return [] {}; } +typedef decltype(g()) VisibleNoLinkage1; +inline auto y = [] {}; +typedef decltype(y) VisibleNoLinkage2; +inline auto h() { struct {} x; return x; } +typedef decltype(h()) VisibleNoLinkage3; + +extern Linkage1 linkage1v; +extern Linkage1::Inner linkage1iv; +extern Linkage2 linkage2v; +extern Linkage2::Inner linkage2iv; +extern Template<Linkage1> linkaget1v; +extern Linkage1 linkage1f(); +void linkage2f(Linkage2); + +void use_linkage() { + &linkage1v, &linkage1iv, &linkage2v, &linkage2iv, &linkaget1v; // expected-warning 5{{unused}} + linkage1f(); + linkage2f({}); +} + +extern NoLinkage1 no_linkage1(); // expected-error {{function 'no_linkage1' is used but not defined in this translation unit}} +extern NoLinkage2 no_linkage2(); // expected-error {{function 'no_linkage2' is used but not defined in this translation unit}} +extern NoLinkage3 no_linkage3(); // expected-error {{function 'no_linkage3' is used but not defined in this translation unit}} + +void use_no_linkage() { + no_linkage1(); // expected-note {{used here}} + no_linkage2(); // expected-note {{used here}} + no_linkage3(); // expected-note {{used here}} +} + +extern VisibleNoLinkage1 visible_no_linkage1(); // expected-warning {{ISO C++ requires a definition}} +extern VisibleNoLinkage2 visible_no_linkage2(); // expected-warning {{ISO C++ requires a definition}} +extern VisibleNoLinkage3 visible_no_linkage3(); // expected-warning {{ISO C++ requires a definition}} + +void use_visible_no_linkage() { + visible_no_linkage1(); // expected-note {{used here}} + visible_no_linkage2(); // expected-note {{used here}} + visible_no_linkage3(); // expected-note {{used here}} +} + +namespace { + struct InternalLinkage {}; +} +InternalLinkage internal_linkage(); // expected-error {{used but not defined}} +void use_internal_linkage() { + internal_linkage(); // expected-note {{used here}} +} + +extern inline int not_defined; // expected-error {{not defined}} +extern inline int defined_after_use; +void use_inline_vars() { + not_defined = 1; // expected-note {{used here}} + defined_after_use = 2; +} +inline int defined_after_use; + +namespace { + template<typename T> struct A { + static const int n; + }; + template<typename T> const int A<T>::n = 3; + static_assert(A<int>::n == 3); + int k = A<float>::n; +} diff --git a/test/CXX/basic/basic.lookup/basic.lookup.qual/class.qual/p2.cpp b/test/CXX/basic/basic.lookup/basic.lookup.qual/class.qual/p2.cpp index 18b18834bb48..cf58a85d849c 100644 --- a/test/CXX/basic/basic.lookup/basic.lookup.qual/class.qual/p2.cpp +++ b/test/CXX/basic/basic.lookup/basic.lookup.qual/class.qual/p2.cpp @@ -73,6 +73,7 @@ void other_contexts() { int a; { X0::X0(a); // expected-error{{qualified reference to 'X0' is a constructor name rather than a type in this context}} + // expected-warning@-1 {{redundant parentheses around declaration of variable named 'a'}} expected-note@-1 2{{}} } } diff --git a/test/CXX/basic/basic.scope/basic.scope.declarative/p4.cpp b/test/CXX/basic/basic.scope/basic.scope.declarative/p4.cpp new file mode 100644 index 000000000000..8c14546edc74 --- /dev/null +++ b/test/CXX/basic/basic.scope/basic.scope.declarative/p4.cpp @@ -0,0 +1,19 @@ +// RUN: %clang_cc1 -std=c++2a -verify %s + +namespace TagVs { + struct Bindable { int a; }; + struct binding_a {}; // expected-note {{previous}} + auto [binding_a] = Bindable{}; // expected-error {{redefinition}} + auto [binding_b] = Bindable{}; // expected-note {{previous}} + struct binding_b {}; // expected-error {{redefinition}} + + struct vartemplate_a {}; // expected-note {{previous}} + template<typename T> int vartemplate_a; // expected-error {{redefinition}} + template<typename T> int vartemplate_b; // expected-note {{previous}} + struct vartemplate_b {}; // expected-error {{redefinition}} + + struct aliastemplate_a {}; // expected-note {{previous}} + template<typename T> using aliastemplate_a = int; // expected-error {{redefinition}} + template<typename T> using aliastemplate_b = int; // expected-note {{previous}} + struct aliastemplate_b {}; // expected-error {{redefinition}} +} diff --git a/test/CXX/class/class.static/class.static.data/p3.cpp b/test/CXX/class/class.static/class.static.data/p3.cpp index 413017d13351..5640bc30ad4c 100644 --- a/test/CXX/class/class.static/class.static.data/p3.cpp +++ b/test/CXX/class/class.static/class.static.data/p3.cpp @@ -50,4 +50,4 @@ U<NonLit> u2; // expected-note {{here}} static_assert(U<int>::a == 0, ""); -constexpr int outofline = (U<NonLit>::d, 0); // expected-note {{here}} expected-warning {{unused}} +constexpr int outofline = (U<NonLit>::d, 0); // expected-note {{here}} diff --git a/test/CXX/concepts-ts/dcl.dcl/lit.cfg.py b/test/CXX/concepts-ts/dcl.dcl/lit.cfg.py new file mode 100644 index 000000000000..c705e3cb93b4 --- /dev/null +++ b/test/CXX/concepts-ts/dcl.dcl/lit.cfg.py @@ -0,0 +1,26 @@ +# -*- Python -*- + +import os +import lit.formats + +from lit.llvm import llvm_config + +# Configuration file for the 'lit' test runner. + +# name: The name of this test suite. +config.name = 'Clang-Concepts-TS-Unsupported' + +# testFormat: The test format to use to interpret tests. +# +# For now we require '&&' between commands, until they get globally killed and +# the test runner updated. +config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell) + +# suffixes: A list of file extensions to treat as test files. +config.suffixes = ['.c', '.cpp', '.cppm', '.m', '.mm', '.cu', + '.ll', '.cl', '.s', '.S', '.modulemap', '.test', '.rs'] + +config.unsupported = True + +# test_source_root: The root path where tests are located. +config.test_source_root = os.path.dirname(__file__) diff --git a/test/CXX/conv/conv.prom/p2.cpp b/test/CXX/conv/conv.prom/p2.cpp index ca64cfa8d0ec..c5ac9112d887 100644 --- a/test/CXX/conv/conv.prom/p2.cpp +++ b/test/CXX/conv/conv.prom/p2.cpp @@ -1,5 +1,5 @@ // RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -triple x86_64-pc-linux-gnu -ffreestanding %s -// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -triple x86_64-pc-linux-gnu -ffreestanding -fshort-wchar %s +// RUN: %clang_cc1 -fsyntax-only -verify -std=c++0x -triple x86_64-pc-linux-gnu -ffreestanding -fwchar-type=short -fno-signed-wchar %s // expected-no-diagnostics #include <stdint.h> diff --git a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.depend/p1.cpp b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.depend/p1.cpp index 9f7ef3ace9c2..6cf27af3230b 100644 --- a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.depend/p1.cpp +++ b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.depend/p1.cpp @@ -7,8 +7,8 @@ [[carries_dependency]] void f1(); // FIXME: warn here [[carries_dependency]] int f2(); // ok int f3(int param [[carries_dependency]]); // ok -[[carries_dependency]] int (*f4)(); // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}} -int (*f5 [[carries_dependency]])(); // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}} +[[carries_dependency]] int (*f4)(); // expected-error {{'carries_dependency' attribute only applies to parameters, Objective-C methods, and functions}} +int (*f5 [[carries_dependency]])(); // expected-error {{'carries_dependency' attribute only applies to}} int (*f6)() [[carries_dependency]]; // expected-error {{'carries_dependency' attribute cannot be applied to types}} int (*f7)(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}} int (((f8)))(int n [[carries_dependency]]); // ok @@ -21,7 +21,7 @@ struct S { }; void f() { [[carries_dependency]] int f(int n [[carries_dependency]]); // ok - [[carries_dependency]] // expected-error {{'carries_dependency' attribute only applies to functions, methods, and parameters}} + [[carries_dependency]] // expected-error {{'carries_dependency' attribute only applies to}} int (*p)(int n [[carries_dependency]]); // expected-error {{'[[carries_dependency]]' attribute only allowed on parameter in a function declaration}} } diff --git a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.fallthrough/p1.cpp b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.fallthrough/p1.cpp index e7c90339a214..f267d9067bcc 100644 --- a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.fallthrough/p1.cpp +++ b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.fallthrough/p1.cpp @@ -1,4 +1,4 @@ -// RUN: %clang_cc1 -std=c++1z -verify %s +// RUN: %clang_cc1 -fsyntax-only -std=c++1z -verify %s void f(int n) { switch (n) { diff --git a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p1.cpp b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p1.cpp index e7a238241295..4425416650ea 100644 --- a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p1.cpp +++ b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p1.cpp @@ -7,4 +7,4 @@ struct [[nodiscard("Wrong")]] S3 {}; // expected-error {{'nodiscard' cannot have [[nodiscard]] int f(); enum [[nodiscard]] E {}; -namespace [[nodiscard]] N {} // expected-warning {{'nodiscard' attribute only applies to functions, methods, enums, and classes}} +namespace [[nodiscard]] N {} // expected-warning {{'nodiscard' attribute only applies to Objective-C methods, enums, structs, unions, classes, functions, and function pointers}} diff --git a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp index 072f5e74aabb..49c418a68764 100644 --- a/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp +++ b/test/CXX/dcl.dcl/dcl.attr/dcl.attr.nodiscard/p2.cpp @@ -9,21 +9,33 @@ enum [[nodiscard]] E {}; E get_e(); [[nodiscard]] int get_i(); +[[nodiscard]] volatile int &get_vi(); void f() { get_s(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} get_i(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} + get_vi(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} get_e(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} // Okay, warnings are not encouraged get_s_ref(); (void)get_s(); (void)get_i(); + (void)get_vi(); (void)get_e(); } +[[nodiscard]] volatile char &(*fp)(); +void g() { + fp(); // expected-warning {{ignoring return value of function declared with 'nodiscard' attribute}} + + // OK, warning suppressed. + (void)fp(); +} #ifdef EXT // expected-warning@4 {{use of the 'nodiscard' attribute is a C++17 extension}} // expected-warning@8 {{use of the 'nodiscard' attribute is a C++17 extension}} // expected-warning@11 {{use of the 'nodiscard' attribute is a C++17 extension}} +// expected-warning@12 {{use of the 'nodiscard' attribute is a C++17 extension}} +// expected-warning@28 {{use of the 'nodiscard' attribute is a C++17 extension}} #endif diff --git a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp index 0b7a902f9378..13721518e6f9 100644 --- a/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp +++ b/test/CXX/dcl.dcl/dcl.spec/dcl.stc/p2.cpp @@ -39,6 +39,7 @@ struct S { void foo(auto int ap, register int rp) { #if __cplusplus >= 201103L // C++11 or later // expected-warning@-2 {{'auto' storage class specifier is not permitted in C++11, and will not be supported in future releases}} +// expected-warning@-3 {{'register' storage class specifier is deprecated}} #endif auto int abo; #if __cplusplus >= 201103L // C++11 or later diff --git a/test/CXX/drs/dr11xx.cpp b/test/CXX/drs/dr11xx.cpp new file mode 100644 index 000000000000..81fbc1e3ef1b --- /dev/null +++ b/test/CXX/drs/dr11xx.cpp @@ -0,0 +1,30 @@ +// RUN: %clang_cc1 -std=c++98 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++11 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++14 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++17 %s -verify -fexceptions -fcxx-exceptions -pedantic-errors +// RUN: %clang_cc1 -std=c++2a %s -verify -fexceptions -fcxx-exceptions -pedantic-errors + +namespace dr1113 { // dr1113: partial + namespace named { + extern int a; // expected-note {{previous}} + static int a; // expected-error {{static declaration of 'a' follows non-static}} + } + namespace { + extern int a; + static int a; // ok, both declarations have internal linkage + int b = a; + } + + // FIXME: Per DR1113 and DR4, this is ill-formed due to ambiguity: the second + // 'f' has internal linkage, and so does not have C language linkage, so is + // not a redeclaration of the first 'f'. + // + // To avoid a breaking change here, Clang ignores the "internal linkage" effect + // of anonymous namespaces on declarations declared within an 'extern "C"' + // linkage-specification. + extern "C" void f(); + namespace { + extern "C" void f(); + } + void g() { f(); } +} diff --git a/test/CXX/drs/dr4xx.cpp b/test/CXX/drs/dr4xx.cpp index 1a5976eadaff..d27adc428d51 100644 --- a/test/CXX/drs/dr4xx.cpp +++ b/test/CXX/drs/dr4xx.cpp @@ -22,6 +22,9 @@ namespace dr401 { // dr401: yes class B { protected: typedef int type; // expected-note {{protected}} +#if __cplusplus == 199711L + // expected-note@-2 {{protected}} +#endif }; class C { @@ -593,10 +596,10 @@ namespace dr447 { // dr447: yes U<__builtin_offsetof(A, n)>::type a; U<__builtin_offsetof(T, n)>::type b; // expected-error +{{}} expected-warning 0+{{}} // as an extension, we allow the member-designator to include array indices - g(__builtin_offsetof(A, a[0])).h<int>(); // expected-error {{extension}} - g(__builtin_offsetof(A, a[N])).h<int>(); // expected-error {{extension}} - U<__builtin_offsetof(A, a[0])>::type c; // expected-error {{extension}} - U<__builtin_offsetof(A, a[N])>::type d; // expected-error {{extension}} expected-error +{{}} expected-warning 0+{{}} + g(__builtin_offsetof(A, a[0])).h<int>(); + g(__builtin_offsetof(A, a[N])).h<int>(); + U<__builtin_offsetof(A, a[0])>::type c; + U<__builtin_offsetof(A, a[N])>::type d; // expected-error +{{}} expected-warning 0+{{}} } } diff --git a/test/CXX/except/except.spec/p1.cpp b/test/CXX/except/except.spec/p1.cpp index fa53c9f5d23f..03d75326a643 100644 --- a/test/CXX/except/except.spec/p1.cpp +++ b/test/CXX/except/except.spec/p1.cpp @@ -86,3 +86,12 @@ namespace PR11084 { f<0>(); // expected-note{{in instantiation of function template specialization}} } } + +namespace FuncTmplNoexceptError { + int a = 0; + // expected-error@+1{{argument to noexcept specifier must be a constant expression}} + template <class T> T f() noexcept(a++){ return {};} + void g(){ + f<int>(); + } +}; diff --git a/test/CXX/expr/expr.const/p2-0x.cpp b/test/CXX/expr/expr.const/p2-0x.cpp index 6d46bf5d77dd..4daed23bf9c6 100644 --- a/test/CXX/expr/expr.const/p2-0x.cpp +++ b/test/CXX/expr/expr.const/p2-0x.cpp @@ -145,19 +145,19 @@ namespace UndefinedBehavior { constexpr int int_min = ~0x7fffffff; constexpr int minus_int_min = -int_min; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}} - constexpr int div0 = 3 / 0; // expected-error {{constant expression}} expected-note {{division by zero}} expected-warning {{undefined}} - constexpr int mod0 = 3 % 0; // expected-error {{constant expression}} expected-note {{division by zero}} expected-warning {{undefined}} + constexpr int div0 = 3 / 0; // expected-error {{constant expression}} expected-note {{division by zero}} + constexpr int mod0 = 3 % 0; // expected-error {{constant expression}} expected-note {{division by zero}} constexpr int int_min_div_minus_1 = int_min / -1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}} constexpr int int_min_mod_minus_1 = int_min % -1; // expected-error {{constant expression}} expected-note {{value 2147483648 is outside the range}} - constexpr int shl_m1 = 0 << -1; // expected-error {{constant expression}} expected-note {{negative shift count -1}} expected-warning {{negative}} + constexpr int shl_m1 = 0 << -1; // expected-error {{constant expression}} expected-note {{negative shift count -1}} constexpr int shl_0 = 0 << 0; // ok constexpr int shl_31 = 0 << 31; // ok - constexpr int shl_32 = 0 << 32; // expected-error {{constant expression}} expected-note {{shift count 32 >= width of type 'int' (32}} expected-warning {{>= width of type}} + constexpr int shl_32 = 0 << 32; // expected-error {{constant expression}} expected-note {{shift count 32 >= width of type 'int' (32}} constexpr int shl_unsigned_negative = unsigned(-3) << 1; // ok constexpr int shl_unsigned_into_sign = 1u << 31; // ok constexpr int shl_unsigned_overflow = 1024u << 31; // ok - constexpr int shl_signed_negative = (-3) << 1; // expected-warning {{shifting a negative signed value is undefined}} // expected-error {{constant expression}} expected-note {{left shift of negative value -3}} + constexpr int shl_signed_negative = (-3) << 1; // expected-error {{constant expression}} expected-note {{left shift of negative value -3}} constexpr int shl_signed_ok = 1 << 30; // ok constexpr int shl_signed_into_sign = 1 << 31; // ok (DR1457) constexpr int shl_signed_into_sign_2 = 0x7fffffff << 1; // ok (DR1457) @@ -166,10 +166,10 @@ namespace UndefinedBehavior { constexpr int shl_signed_overflow = 1024 << 31; // expected-error {{constant expression}} expected-note {{signed left shift discards bits}} expected-warning {{requires 43 bits to represent}} constexpr int shl_signed_ok2 = 1024 << 20; // ok - constexpr int shr_m1 = 0 >> -1; // expected-error {{constant expression}} expected-note {{negative shift count -1}} expected-warning {{negative}} + constexpr int shr_m1 = 0 >> -1; // expected-error {{constant expression}} expected-note {{negative shift count -1}} constexpr int shr_0 = 0 >> 0; // ok constexpr int shr_31 = 0 >> 31; // ok - constexpr int shr_32 = 0 >> 32; // expected-error {{constant expression}} expected-note {{shift count 32 >= width of type}} expected-warning {{>= width of type}} + constexpr int shr_32 = 0 >> 32; // expected-error {{constant expression}} expected-note {{shift count 32 >= width of type}} struct S { int m; diff --git a/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp b/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp index b9b8cd76c011..1cc1fd974ca5 100644 --- a/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp +++ b/test/CXX/expr/expr.prim/expr.prim.lambda/p8.cpp @@ -8,7 +8,7 @@ class X0 { (void)[this, this] () {}; // expected-error {{'this' can appear only once}} (void)[=, foo] () {}; // expected-error {{'&' must precede a capture when}} (void)[=, &foo] () {}; - (void)[=, this] () {}; // expected-error {{'this' cannot be explicitly captured}} + (void)[=, this] () {}; // expected-warning {{C++2a extension}} (void)[&, foo] () {}; (void)[&, &foo] () {}; // expected-error {{'&' cannot precede a capture when}} (void)[&, this] () {}; @@ -23,7 +23,7 @@ struct S2 { void S2::f(int i) { (void)[&, i]{ }; (void)[&, &i]{ }; // expected-error{{'&' cannot precede a capture when the capture default is '&'}} - (void)[=, this]{ }; // expected-error{{'this' cannot be explicitly captured}} + (void)[=, this]{ }; // expected-warning{{C++2a extension}} (void)[=]{ this->g(i); }; (void)[i, i]{ }; // expected-error{{'i' can appear only once in a capture list}} (void)[i(0), i(1)]{ }; // expected-error{{'i' can appear only once in a capture list}} diff --git a/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp b/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp index 7305bd1f53e2..a3a2f712c800 100644 --- a/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp +++ b/test/CXX/expr/expr.unary/expr.new/p2-cxx0x.cpp @@ -9,12 +9,14 @@ struct only { void f() { only<const int*> p = new const auto (0); only<double*> q = new (auto) (0.0); + only<char*> r = new auto {'a'}; new auto; // expected-error{{new expression for type 'auto' requires a constructor argument}} new (const auto)(); // expected-error{{new expression for type 'const auto' requires a constructor argument}} new (auto) (1,2,3); // expected-error{{new expression for type 'auto' contains multiple constructor arguments}} - new auto {1,2,3}; // expected-error{{new expression for type 'auto' cannot use list-initialization}} - new auto ({1,2,3}); // expected-error{{new expression for type 'auto' cannot use list-initialization}} + new auto {}; // expected-error{{new expression for type 'auto' requires a constructor argument}} + new auto {1,2,3}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}} + new auto ({1,2,3}); // expected-error{{new expression for type 'auto' contains multiple constructor arguments}} } void p2example() { diff --git a/test/CXX/expr/expr.unary/expr.new/p2-cxx14.cpp b/test/CXX/expr/expr.unary/expr.new/p2-cxx14.cpp new file mode 100644 index 000000000000..70bbc4805c43 --- /dev/null +++ b/test/CXX/expr/expr.unary/expr.new/p2-cxx14.cpp @@ -0,0 +1,10 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 -pedantic + +void f() { + new auto('a'); + new auto {2}; // expected-warning {{ISO C++ standards before C++17 do not allow new expression for type 'auto' to use list-initialization}} + new auto {1, 2}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}} + new auto {}; // expected-error{{new expression for type 'auto' requires a constructor argument}} + new decltype(auto)({1}); // expected-warning {{ISO C++ standards before C++17 do not allow new expression for type 'decltype(auto)' to use list-initialization}} + new decltype(auto)({1, 2}); // expected-error{{new expression for type 'decltype(auto)' contains multiple constructor arguments}} +} diff --git a/test/CXX/expr/expr.unary/expr.new/p2-cxx1z.cpp b/test/CXX/expr/expr.unary/expr.new/p2-cxx1z.cpp new file mode 100644 index 000000000000..6e76075ab16f --- /dev/null +++ b/test/CXX/expr/expr.unary/expr.new/p2-cxx1z.cpp @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++14 +// RUN: %clang_cc1 -fsyntax-only -verify %s -std=c++17 -pedantic + +void f() { + new auto('a'); + new auto {2}; + new auto {1, 2}; // expected-error{{new expression for type 'auto' contains multiple constructor arguments}} + new auto {}; // expected-error{{new expression for type 'auto' requires a constructor argument}} + new decltype(auto)({1}); + new decltype(auto)({1, 2}); // expected-error{{new expression for type 'decltype(auto)' contains multiple constructor arguments}} +} diff --git a/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cpp b/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cpp index dc6a3635a8ee..79e68655b45b 100644 --- a/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cpp +++ b/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cpp @@ -2,17 +2,14 @@ // RUN: %clang_cc1 -fmodules-ts %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s --implicit-check-not=unused --implicit-check-not=global_module // CHECK-DAG: @extern_var_exported = external global -// FIXME: Should this be 'external global'? // CHECK-DAG: @inline_var_exported = linkonce_odr global -// CHECK-DAG: @_ZL19static_var_exported = external global -// CHECK-DAG: @const_var_exported = external constant +// CHECK-DAG: @_ZW6ModuleE19static_var_exported = available_externally global i32 0, +// CHECK-DAG: @const_var_exported = available_externally constant i32 3, // -// FIXME: The module name should be mangled into all of these. -// CHECK-DAG: @extern_var_module_linkage = external global -// FIXME: Should this be 'external global'? -// CHECK-DAG: @inline_var_module_linkage = linkonce_odr global -// CHECK-DAG: @_ZL25static_var_module_linkage = external global -// CHECK-DAG: @_ZL24const_var_module_linkage = external constant +// CHECK-DAG: @_ZW6ModuleE25extern_var_module_linkage = external global +// CHECK-DAG: @_ZW6ModuleE25inline_var_module_linkage = linkonce_odr global +// CHECK-DAG: @_ZW6ModuleE25static_var_module_linkage = available_externally global i32 0, +// CHECK-DAG: @_ZW6ModuleE24const_var_module_linkage = available_externally constant i32 3, module Module; @@ -28,15 +25,13 @@ void use() { (void)&const_var_exported; // FIXME: This symbol should not be visible here. - // CHECK: declare {{.*}}@_ZL26used_static_module_linkagev + // CHECK: declare {{.*}}@_ZW6ModuleE26used_static_module_linkagev used_static_module_linkage(); - // FIXME: The module name should be mangled into the name of this function. - // CHECK: define linkonce_odr {{.*}}@_Z26used_inline_module_linkagev + // CHECK: define linkonce_odr {{.*}}@_ZW6ModuleE26used_inline_module_linkagev used_inline_module_linkage(); - // FIXME: The module name should be mangled into the name of this function. - // CHECK: declare {{.*}}@_Z24noninline_module_linkagev + // CHECK: declare {{.*}}@_ZW6ModuleE24noninline_module_linkagev noninline_module_linkage(); (void)&extern_var_module_linkage; diff --git a/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cppm b/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cppm index d452f741a0fb..15d1114fb03f 100644 --- a/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cppm +++ b/test/CXX/modules-ts/basic/basic.def.odr/p4/module.cppm @@ -11,17 +11,20 @@ // can discard this global and its initializer (if any), and other TUs are not // permitted to run the initializer for this variable. // CHECK-DAG: @inline_var_exported = linkonce_odr global -// CHECK-DAG: @_ZL19static_var_exported = global +// CHECK-DAG: @_ZW6ModuleE19static_var_exported = global // CHECK-DAG: @const_var_exported = constant // -// FIXME: The module name should be mangled into all of these. -// CHECK-DAG: @extern_var_module_linkage = external global +// CHECK-DAG: @_ZW6ModuleE25extern_var_module_linkage = external global // FIXME: Should this be 'weak_odr global'? Presumably it must be, since we // can discard this global and its initializer (if any), and other TUs are not // permitted to run the initializer for this variable. -// CHECK-DAG: @inline_var_module_linkage = linkonce_odr global -// CHECK-DAG: @_ZL25static_var_module_linkage = global -// CHECK-DAG: @_ZL24const_var_module_linkage = constant +// CHECK-DAG: @_ZW6ModuleE25inline_var_module_linkage = linkonce_odr global +// CHECK-DAG: @_ZW6ModuleE25static_var_module_linkage = global +// CHECK-DAG: @_ZW6ModuleE24const_var_module_linkage = constant +// +// CHECK-DAG: @_ZW6ModuleE25unused_var_module_linkage = global i32 4 +// CHECK-DAG: @_ZW6ModuleE32unused_static_var_module_linkage = global i32 5 +// CHECK-DAG: @_ZW6ModuleE31unused_const_var_module_linkage = constant i32 7 static void unused_static_global_module() {} static void used_static_global_module() {} @@ -57,9 +60,9 @@ export module Module; export { // FIXME: These should be ill-formed: you can't export an internal linkage // symbol, per [dcl.module.interface]p2. - // CHECK: define void {{.*}}@_ZL22unused_static_exportedv + // CHECK: define void {{.*}}@_ZW6ModuleE22unused_static_exportedv static void unused_static_exported() {} - // CHECK: define void {{.*}}@_ZL20used_static_exportedv + // CHECK: define void {{.*}}@_ZW6ModuleE20used_static_exportedv static void used_static_exported() {} inline void unused_inline_exported() {} @@ -88,11 +91,9 @@ export { // FIXME: Ideally we wouldn't emit this as its name is not visible outside this // TU, but this module interface might contain a template that can use this // function so we conservatively emit it for now. -// FIXME: The module name should be mangled into the name of this function. -// CHECK: define void {{.*}}@_ZL28unused_static_module_linkagev +// CHECK: define void {{.*}}@_ZW6ModuleE28unused_static_module_linkagev static void unused_static_module_linkage() {} -// FIXME: The module name should be mangled into the name of this function. -// CHECK: define void {{.*}}@_ZL26used_static_module_linkagev +// CHECK: define void {{.*}}@_ZW6ModuleE26used_static_module_linkagev static void used_static_module_linkage() {} inline void unused_inline_module_linkage() {} @@ -103,12 +104,10 @@ inline int inline_var_module_linkage; static int static_var_module_linkage; const int const_var_module_linkage = 3; -// FIXME: The module name should be mangled into the name of this function. -// CHECK: define void {{.*}}@_Z24noninline_module_linkagev +// CHECK: define void {{.*}}@_ZW6ModuleE24noninline_module_linkagev void noninline_module_linkage() { used_static_module_linkage(); - // FIXME: The module name should be mangled into the name of this function. - // CHECK: define linkonce_odr {{.*}}@_Z26used_inline_module_linkagev + // CHECK: define linkonce_odr {{.*}}@_ZW6ModuleE26used_inline_module_linkagev used_inline_module_linkage(); (void)&extern_var_module_linkage; @@ -116,3 +115,15 @@ void noninline_module_linkage() { (void)&static_var_module_linkage; (void)&const_var_module_linkage; } + +int unused_var_module_linkage = 4; +static int unused_static_var_module_linkage = 5; +inline int unused_inline_var_module_linkage = 6; +const int unused_const_var_module_linkage = 7; + +struct a { + struct b {}; + struct c {}; +}; +// CHECK: define void @_ZW6ModuleE1fW_0EN1a1bEW_0ENS_1cE( +void f(a::b, a::c) {} diff --git a/test/CXX/modules-ts/basic/basic.def.odr/p4/user.cpp b/test/CXX/modules-ts/basic/basic.def.odr/p4/user.cpp index f6e0238c6b4b..5e9f7ecf5bab 100644 --- a/test/CXX/modules-ts/basic/basic.def.odr/p4/user.cpp +++ b/test/CXX/modules-ts/basic/basic.def.odr/p4/user.cpp @@ -2,11 +2,9 @@ // RUN: %clang_cc1 -fmodules-ts %s -triple %itanium_abi_triple -fmodule-file=%t -emit-llvm -o - | FileCheck %s --implicit-check-not=unused --implicit-check-not=global_module // CHECK-DAG: @extern_var_exported = external global -// FIXME: Should this be 'external global'? // CHECK-DAG: @inline_var_exported = linkonce_odr global -// FIXME: These should be 'extern global' and 'extern constant'. -// CHECK-DAG: @_ZL19static_var_exported = global -// CHECK-DAG: @const_var_exported = constant +// CHECK-DAG: @_ZW6ModuleE19static_var_exported = available_externally global i32 0 +// CHECK-DAG: @const_var_exported = available_externally constant i32 3 import Module; diff --git a/test/CXX/modules-ts/basic/basic.def.odr/p6/global-vs-module.cpp b/test/CXX/modules-ts/basic/basic.def.odr/p6/global-vs-module.cpp new file mode 100644 index 000000000000..cceca5106cae --- /dev/null +++ b/test/CXX/modules-ts/basic/basic.def.odr/p6/global-vs-module.cpp @@ -0,0 +1,55 @@ +// RUN: %clang_cc1 -fmodules-ts -verify -std=c++17 %s +// RUN: %clang_cc1 -fmodules-ts -verify -std=c++17 %s -DEXPORT +// RUN: %clang_cc1 -fmodules-ts -verify -std=c++17 %s -DUSING + +#ifndef NO_GLOBAL +extern int var; // expected-note {{previous declaration is here}} +int func(); // expected-note {{previous declaration is here}} +struct str; // expected-note {{previous declaration is here}} +using type = int; + +template<typename> extern int var_tpl; // expected-note {{previous declaration is here}} +template<typename> int func_tpl(); // expected-note-re {{{{previous declaration is here|target of using declaration}}}} +template<typename> struct str_tpl; // expected-note {{previous declaration is here}} +template<typename> using type_tpl = int; // expected-note {{previous declaration is here}} + +typedef int type; +namespace ns { using ::func; } +namespace ns_alias = ns; +#endif + +export module M; + +#ifdef USING +using ::var; +using ::func; +using ::str; +using ::type; +using ::var_tpl; +using ::func_tpl; // expected-note {{using declaration}} +using ::str_tpl; +using ::type_tpl; +#endif + +#ifdef EXPORT +export { +#endif + +extern int var; // expected-error {{declaration of 'var' in module M follows declaration in the global module}} +int func(); // expected-error {{declaration of 'func' in module M follows declaration in the global module}} +struct str; // expected-error {{declaration of 'str' in module M follows declaration in the global module}} +using type = int; + +template<typename> extern int var_tpl; // expected-error {{declaration of 'var_tpl' in module M follows declaration in the global module}} +// FIXME: Is this the right diagnostic in the -DUSING case? +template<typename> int func_tpl(); // expected-error-re {{{{declaration of 'func_tpl' in module M follows declaration in the global module|conflicts with target of using declaration}}}} +template<typename> struct str_tpl; // expected-error {{declaration of 'str_tpl' in module M follows declaration in the global module}} +template<typename> using type_tpl = int; // expected-error {{declaration of 'type_tpl' in module M follows declaration in the global module}} + +typedef int type; +namespace ns { using ::func; } +namespace ns_alias = ns; + +#ifdef EXPORT +} +#endif diff --git a/test/CXX/modules-ts/basic/basic.def.odr/p6/module-vs-global.cpp b/test/CXX/modules-ts/basic/basic.def.odr/p6/module-vs-global.cpp new file mode 100644 index 000000000000..f58506dd9c46 --- /dev/null +++ b/test/CXX/modules-ts/basic/basic.def.odr/p6/module-vs-global.cpp @@ -0,0 +1,19 @@ +// RUN: rm -rf %t +// RUN: %clang_cc1 -fmodules-ts -emit-module-interface -std=c++17 %S/global-vs-module.cpp -o %t -DNO_GLOBAL -DEXPORT +// RUN: %clang_cc1 -fmodules-ts -verify -std=c++17 %s -fmodule-file=%t + +import M; + +extern int var; // expected-error {{declaration of 'var' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:38 {{previous}} +int func(); // expected-error {{declaration of 'func' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:39 {{previous}} +struct str; // expected-error {{declaration of 'str' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:40 {{previous}} +using type = int; + +template<typename> extern int var_tpl; // expected-error {{declaration of 'var_tpl' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:43 {{previous}} +template<typename> int func_tpl(); // expected-error {{declaration of 'func_tpl' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:45 {{previous}} +template<typename> struct str_tpl; // expected-error {{declaration of 'str_tpl' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:46 {{previous}} +template<typename> using type_tpl = int; // expected-error {{declaration of 'type_tpl' in the global module follows declaration in module M}} expected-note@global-vs-module.cpp:47 {{previous}} + +typedef int type; +namespace ns { using ::func; } +namespace ns_alias = ns; diff --git a/test/CXX/modules-ts/basic/basic.def.odr/p6/module-vs-module.cpp b/test/CXX/modules-ts/basic/basic.def.odr/p6/module-vs-module.cpp new file mode 100644 index 000000000000..39e210c4ad80 --- /dev/null +++ b/test/CXX/modules-ts/basic/basic.def.odr/p6/module-vs-module.cpp @@ -0,0 +1,44 @@ +// RUN: rm -rf %t +// RUN: mkdir %t +// +// Some of the following tests intentionally have no -verify in their RUN +// lines; we are testing that those cases do not produce errors. +// +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %S/global-vs-module.cpp -emit-module-interface -o %t/M.pcm -DNO_GLOBAL -DEXPORT +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/M.pcm -DMODULE_INTERFACE -verify +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/M.pcm -DMODULE_INTERFACE -DNO_IMPORT +// +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/M.pcm -emit-module-interface -o %t/N.pcm -DMODULE_INTERFACE -DNO_ERRORS +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/N.pcm -verify +// FIXME: Once we start importing "import" declarations properly, this should +// be rejected (-verify should be added to the following line). +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/N.pcm -DNO_IMPORT +// +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/M.pcm -emit-module-interface -o %t/N-no-M.pcm -DMODULE_INTERFACE -DNO_ERRORS -DNO_IMPORT +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/N-no-M.pcm -verify +// RUN: %clang_cc1 -fmodules-ts -std=c++17 %s -fmodule-file=%t/N-no-M.pcm -DNO_IMPORT + +#ifdef MODULE_INTERFACE +export +#endif +module N; + +#ifndef NO_IMPORT +import M; +#endif + +#ifndef NO_ERRORS +extern int var; // expected-error {{declaration of 'var' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:38 {{previous}} +int func(); // expected-error {{declaration of 'func' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:39 {{previous}} +struct str; // expected-error {{declaration of 'str' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:40 {{previous}} +using type = int; + +template<typename> extern int var_tpl; // expected-error {{declaration of 'var_tpl' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:43 {{previous}} +template<typename> int func_tpl(); // expected-error {{declaration of 'func_tpl' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:45 {{previous}} +template<typename> struct str_tpl; // expected-error {{declaration of 'str_tpl' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:46 {{previous}} +template<typename> using type_tpl = int; // expected-error {{declaration of 'type_tpl' in module N follows declaration in module M}} expected-note@global-vs-module.cpp:47 {{previous}} + +typedef int type; +namespace ns { using ::func; } +namespace ns_alias = ns; +#endif diff --git a/test/CXX/modules-ts/basic/basic.link/module-declaration.cpp b/test/CXX/modules-ts/basic/basic.link/module-declaration.cpp index ee696d14585c..feb0afdda07b 100644 --- a/test/CXX/modules-ts/basic/basic.link/module-declaration.cpp +++ b/test/CXX/modules-ts/basic/basic.link/module-declaration.cpp @@ -9,7 +9,6 @@ // RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface -fmodule-file=%t/x.pcm %t/x.y.cppm -o %t/x.y.pcm // // Module implementation for unknown and known module. (The former is ill-formed.) -// FIXME: TEST=1 should fail because we don't have an interface for module z. // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ // RUN: -DTEST=1 -DEXPORT= -DPARTITION= -DMODULE_NAME=z // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ @@ -32,24 +31,26 @@ // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ // RUN: -DTEST=7 -DEXPORT= -DPARTITION=elderberry -DMODULE_NAME=z // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ -// RUN: -DTEST=8 -DEXPORT= -DPARTITION= -DMODULE_NAME='z [[]]' +// RUN: -DTEST=8 -DEXPORT=export -DPARTITION= -DMODULE_NAME='z [[]]' // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ -// RUN: -DTEST=9 -DEXPORT= -DPARTITION= -DMODULE_NAME='z [[fancy]]' +// RUN: -DTEST=9 -DEXPORT=export -DPARTITION= -DMODULE_NAME='z [[fancy]]' // RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ -// RUN: -DTEST=10 -DEXPORT= -DPARTITION= -DMODULE_NAME='z [[maybe_unused]]' +// RUN: -DTEST=10 -DEXPORT=export -DPARTITION= -DMODULE_NAME='z [[maybe_unused]]' EXPORT module PARTITION MODULE_NAME; #if TEST == 4 // expected-error@-2 {{redefinition of module 'x'}} -// expected-note-re@module-declaration.cpp:* {{loaded from '{{.*}}/x.pcm'}} +// expected-note-re@module-declaration.cpp:* {{loaded from '{{.*[/\\]}}x.pcm'}} #elif TEST == 6 // expected-error@-5 {{module partition must be declared 'export'}} #elif TEST == 7 -// expected-error@-7 {{expected ';'}} expected-error@-7 {{requires a type specifier}} +// expected-error@-7 {{expected ';'}} expected-error@-7 {{requires a type specifier}} expected-error@-7 {{definition of module 'elderberry' is not available}} #elif TEST == 9 // expected-warning@-9 {{unknown attribute 'fancy' ignored}} #elif TEST == 10 // expected-error-re@-11 {{'maybe_unused' attribute cannot be applied to a module{{$}}}} +#elif TEST == 1 +// expected-error@-13 {{definition of module 'z' is not available}} #else // expected-no-diagnostics #endif diff --git a/test/CXX/modules-ts/basic/basic.link/p3.cppm b/test/CXX/modules-ts/basic/basic.link/p3.cppm new file mode 100644 index 000000000000..8ff141c5ff6b --- /dev/null +++ b/test/CXX/modules-ts/basic/basic.link/p3.cppm @@ -0,0 +1,11 @@ +// RUN: %clang_cc1 -fmodules-ts -triple x86_64-linux %s -emit-module-interface -o %t +// RUN: %clang_cc1 -fmodules-ts -triple x86_64-linux -x pcm %t -emit-llvm -o - | FileCheck %s + +export module M; + +// CHECK-DAG: @_ZW1ME1a = constant i32 1 +const int a = 1; +// CHECK-DAG: @b = constant i32 2 +export const int b = 2; + +export int f() { return a + b; } diff --git a/test/CXX/modules-ts/basic/basic.search/module-import.cpp b/test/CXX/modules-ts/basic/basic.search/module-import.cpp new file mode 100644 index 000000000000..0b5f39d072a3 --- /dev/null +++ b/test/CXX/modules-ts/basic/basic.search/module-import.cpp @@ -0,0 +1,39 @@ +// Tests for imported module search. +// +// RUN: rm -rf %t +// RUN: mkdir -p %t +// RUN: echo 'export module x; int a, b;' > %t/x.cppm +// RUN: echo 'export module y; import x; int c;' > %t/y.cppm +// RUN: echo 'export module z; import y; int d;' > %t/z.cppm +// +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface %t/x.cppm -o %t/x.pcm +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface -fmodule-file=%t/x.pcm %t/y.cppm -o %t/y.pcm +// +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.pcm -verify %s \ +// RUN: -DMODULE_NAME=x +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/y.pcm -verify %s \ +// RUN: -DMODULE_NAME=y +// +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=x=%t/x.pcm -verify %s \ +// RUN: -DMODULE_NAME=x +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=y=%t/y.pcm -verify %s \ +// RUN: -DMODULE_NAME=y +// +// RUN: mv %t/x.pcm %t/a.pcm +// +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=x=%t/a.pcm -verify %s \ +// RUN: -DMODULE_NAME=x +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/y.pcm -fmodule-file=x=%t/a.pcm -verify %s \ +// RUN: -DMODULE_NAME=y +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=y=%t/y.pcm -fmodule-file=x=%t/a.pcm -verify %s \ +// RUN: -DMODULE_NAME=y +// +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface -fmodule-file=y=%t/y.pcm -fmodule-file=x=%t/a.pcm %t/z.cppm -o %t/z.pcm +// +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=z=%t/z.pcm -fmodule-file=y=%t/y.pcm -fmodule-file=x=%t/a.pcm -verify %s \ +// RUN: -DMODULE_NAME=z +// + +import MODULE_NAME; + +// expected-no-diagnostics diff --git a/test/CXX/modules-ts/codegen-basics.cppm b/test/CXX/modules-ts/codegen-basics.cppm index d1552d9edd26..a85e12df26f6 100644 --- a/test/CXX/modules-ts/codegen-basics.cppm +++ b/test/CXX/modules-ts/codegen-basics.cppm @@ -4,20 +4,18 @@ export module FooBar; export { - // CHECK-LABEL: define i32 @_Z1fv( + // CHECK-DAG: define i32 @_Z1fv( int f() { return 0; } } -// CHECK-LABEL: define weak_odr void @_Z2f2v( +// CHECK-DAG: define weak_odr void @_ZW6FooBarE2f2v( inline void f2() { } -// FIXME: Emit global variables and their initializers with this TU. -// Emit an initialization function that other TUs can call, with guard variable. - -// FIXME: Mangle non-exported symbols so they don't collide with -// non-exported symbols from other modules? +// CHECK-DAG: define void @_ZW6FooBarE2f3v( +static void f3() {} +export void use_f3() { f3(); } -// FIXME: Formally-internal-linkage symbols that are used from an exported -// symbol need a mangled name and external linkage. +// FIXME: Emit global variables and their initializers with this TU. +// Emit an initialization function that other TUs can call, with guard variable? // FIXME: const-qualified variables don't have implicit internal linkage when owned by a module. diff --git a/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.export/p1.cpp b/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.export/p1.cpp new file mode 100644 index 000000000000..ab8c690441ca --- /dev/null +++ b/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.export/p1.cpp @@ -0,0 +1,40 @@ +// RUN: rm -rf %t +// RUN: mkdir -p %t +// +// RUN: echo 'export module a; export class A{};' | %clang_cc1 -x c++ -fmodules-ts -emit-module-interface - -o %t/a.pcm +// RUN: echo 'export module b; export class B{};' | %clang_cc1 -x c++ -fmodules-ts -emit-module-interface - -o %t/b.pcm +// RUN: echo 'export module c; export class C{};' | %clang_cc1 -x c++ -fmodules-ts -emit-module-interface - -o %t/c.pcm +// +// RUN: %clang_cc1 -fmodules-ts -fprebuilt-module-path=%t -emit-module-interface %s -o %t/aggregate.internal.pcm -DAGGREGATE_INTERNAL +// RUN: %clang_cc1 -fmodules-ts -fprebuilt-module-path=%t -emit-module-interface %s -o %t/aggregate.pcm -DAGGREGATE +// +// RUN: %clang_cc1 -fmodules-ts -fprebuilt-module-path=%t %s -verify -DTEST +// expected-no-diagnostics + + +#ifdef AGGREGATE_INTERNAL +export module aggregate.internal; +export import a; +export { + import b; + import c; +} +#endif + + +// Export the above aggregate module. +// This is done to ensure that re-exports are transitive. +#ifdef AGGREGATE +export module aggregate; +export import aggregate.internal; +#endif + + +// For the actual test, just try using the classes from the exported modules +// and hope that they're accessible. +#ifdef TEST +import aggregate; +A a; +B b; +C c; +#endif diff --git a/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.import/p1.cpp b/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.import/p1.cpp index aad31b4b46d1..15900c1f6a3a 100644 --- a/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.import/p1.cpp +++ b/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.import/p1.cpp @@ -2,15 +2,22 @@ // RUN: mkdir -p %t // RUN: echo 'export module x; export int a, b;' > %t/x.cppm // RUN: echo 'export module x.y; export int c;' > %t/x.y.cppm +// RUN: echo 'export module a.b; export int d;' > %t/a.b.cppm // // RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface %t/x.cppm -o %t/x.pcm // RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface -fmodule-file=%t/x.pcm %t/x.y.cppm -o %t/x.y.pcm +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -emit-module-interface %t/a.b.cppm -o %t/a.b.pcm // -// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ -// RUN: -DMODULE_NAME=z -// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -verify %s \ +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -fmodule-file=%t/a.b.pcm -verify %s \ +// RUN: -DMODULE_NAME=z -DINTERFACE +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -fmodule-file=%t/a.b.pcm -verify %s \ +// RUN: -DMODULE_NAME=a.b +// RUN: %clang_cc1 -std=c++1z -fmodules-ts -I%t -fmodule-file=%t/x.y.pcm -fmodule-file=%t/a.b.pcm -verify %s \ // RUN: -DMODULE_X -DMODULE_NAME=x +#ifdef INTERFACE +export +#endif module MODULE_NAME; int use_1 = a; @@ -33,6 +40,7 @@ import x [[noreturn]]; // expected-error {{'noreturn' attribute cannot be applie import x [[blarg::noreturn]]; // expected-warning {{unknown attribute 'noreturn' ignored}} import x.y; +import a.b; // Does not imply existence of module a. import x.; // expected-error {{expected a module name after 'import'}} import .x; // expected-error {{expected a module name after 'import'}} diff --git a/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.interface/p1.cpp b/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.interface/p1.cpp index afe3a7a48589..68f2570dd3e6 100644 --- a/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.interface/p1.cpp +++ b/test/CXX/modules-ts/dcl.dcl/dcl.module/dcl.module.interface/p1.cpp @@ -1,27 +1,28 @@ // RUN: %clang_cc1 -fmodules-ts %s -verify -o /dev/null -// RUN: %clang_cc1 -fmodules-ts %s -DINTERFACE -verify -o /dev/null -// RUN: %clang_cc1 -fmodules-ts %s -DIMPLEMENTATION -verify -o /dev/null +// RUN: %clang_cc1 -fmodules-ts %s -DINTERFACE -verify -emit-module-interface -o %t +// RUN: %clang_cc1 -fmodules-ts %s -DIMPLEMENTATION -verify -fmodule-file=%t -o /dev/null // // RUN: %clang_cc1 -fmodules-ts %s -DBUILT_AS_INTERFACE -emit-module-interface -verify -o /dev/null // RUN: %clang_cc1 -fmodules-ts %s -DINTERFACE -DBUILT_AS_INTERFACE -emit-module-interface -verify -o /dev/null // RUN: %clang_cc1 -fmodules-ts %s -DIMPLEMENTATION -DBUILT_AS_INTERFACE -emit-module-interface -verify -o /dev/null #if INTERFACE +// expected-no-diagnostics export module A; #elif IMPLEMENTATION module A; #ifdef BUILT_AS_INTERFACE // expected-error@-2 {{missing 'export' specifier in module declaration while building module interface}} + #define INTERFACE #endif #else #ifdef BUILT_AS_INTERFACE - // FIXME: Diagnose missing module declaration (at end of TU) + // expected-error@1 {{missing 'export module' declaration in module interface unit}} #endif #endif -export int a; #ifndef INTERFACE -// expected-error@-2 {{export declaration can only be used within a module interface unit}} +export int b; // expected-error {{export declaration can only be used within a module interface unit}} #else -// expected-no-diagnostics +export int a; #endif diff --git a/test/CXX/modules-ts/dcl.dcl/dcl.module/p1.cpp b/test/CXX/modules-ts/dcl.dcl/dcl.module/p1.cpp new file mode 100644 index 000000000000..2393aa184317 --- /dev/null +++ b/test/CXX/modules-ts/dcl.dcl/dcl.module/p1.cpp @@ -0,0 +1,14 @@ +// RUN: %clang_cc1 -std=c++17 -fmodules-ts -verify %s -DFOO=export -DBAR=export +// RUN: %clang_cc1 -std=c++17 -fmodules-ts -verify %s -DFOO=export -DBAR= +// RUN: %clang_cc1 -std=c++17 -fmodules-ts %s -DFOO=export -emit-module-interface -o %t +// RUN: %clang_cc1 -std=c++17 -fmodules-ts %s -fmodule-file=%t -DFOO= +// RUN: %clang_cc1 -std=c++17 -fmodules-ts %s -fmodule-file=%t -DBAR=export +// RUN: %clang_cc1 -std=c++17 -fmodules-ts -verify %s -fmodule-file=%t -DFOO= -DBAR=export + +#ifdef FOO +FOO module foo; // expected-note {{previous module declaration is here}} +#endif + +#ifdef BAR +BAR module bar; // expected-error {{translation unit contains multiple module declarations}} +#endif diff --git a/test/CXX/modules-ts/dcl.dcl/dcl.module/p2.cpp b/test/CXX/modules-ts/dcl.dcl/dcl.module/p2.cpp new file mode 100644 index 000000000000..992715e6b102 --- /dev/null +++ b/test/CXX/modules-ts/dcl.dcl/dcl.module/p2.cpp @@ -0,0 +1,6 @@ +// RUN: %clang_cc1 -fmodules-ts -verify %s + +// A named module shall contain exactly one module interface unit. +module M; // expected-error {{definition of module 'M' is not available; use -fmodule-file= to specify path to precompiled module interface}} + +// FIXME: How do we ensure there is not more than one? diff --git a/test/CXX/over/over.match/over.match.best/p1.cpp b/test/CXX/over/over.match/over.match.best/p1.cpp index fad5bf9a72ee..a933f62a3061 100644 --- a/test/CXX/over/over.match/over.match.best/p1.cpp +++ b/test/CXX/over/over.match/over.match.best/p1.cpp @@ -25,13 +25,13 @@ namespace deduction_guide_example { // FIXME: The standard's example is wrong; we add a remove_ref<...> here to // fix it. - template<typename T, int N = remove_ref<T>::value> A(T&&, int*) -> A<T>; + template<typename T, int N = remove_ref<T>::value> A(T&&, int*) -> A<T**>; A a{1, 0}; extern A<int> a; - A b{a, 0}; + A b{a, 0}; // uses the implicit ctor that is more specialized A<int> *pa = &a; - A<A<int>&> *pb = &b; + A<int> *pb = &b; } // Partial ordering of function template specializations will be tested diff --git a/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p2.cpp b/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p2.cpp index fe1b6a63d75b..cb9541caaddd 100644 --- a/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p2.cpp +++ b/test/CXX/over/over.match/over.match.funcs/over.match.class.deduct/p2.cpp @@ -6,9 +6,10 @@ namespace Explicit { template<typename T> struct A { A(T); A(T*); + A(...); }; template<typename T> A(T) -> A<T>; - template<typename T> explicit A(T*) -> A<T>; // expected-note {{explicit}} + template<typename T> explicit A(T*) -> A<T**>; // expected-note {{explicit}} int *p; A a(p); @@ -16,10 +17,71 @@ namespace Explicit { A c{p}; A d = {p}; // expected-error {{selected an explicit deduction guide}} - using X = A<int>; - using Y = A<int*>; + using X = A<int**>; + using Y = A<int>; // uses the implicit guide, being more specialized than the eligible user-defined deduction guides. using X = decltype(a); using Y = decltype(b); using X = decltype(c); } + + +namespace std { + template<typename T> struct initializer_list { + const T *ptr; + __SIZE_TYPE__ size; + initializer_list(); + }; +} + +namespace p0702r1 { + template<typename T> struct X { // expected-note {{candidate}} + X(std::initializer_list<T>); // expected-note {{candidate}} + }; + + X xi = {0}; + X xxi = {xi}; + extern X<int> xi; + // Prior to P0702R1, this is X<X<int>>. + extern X<int> xxi; + + struct Y : X<int> {}; + Y y {{0}}; + X xy {y}; + extern X<int> xy; + + struct Z : X<int>, X<float> {}; + Z z = {{0}, {0.0f}}; + // This is not X<Z> even though that would work. Instead, it's ambiguous + // between X<int> and X<float>. + X xz = {z}; // expected-error {{no viable constructor or deduction guide}} +} +namespace pr34970 { +//https://bugs.llvm.org/show_bug.cgi?id=34970 + +template <typename X, typename Y> struct IsSame { + static constexpr bool value = false; +}; + +template <typename Z> struct IsSame<Z, Z> { + static constexpr bool value = true; +}; + +template <typename T> struct Optional { + template <typename U> Optional(U&&) { } +}; + +template <typename A> Optional(A) -> Optional<A>; + +int main() { + Optional opt(1729); + Optional dupe(opt); + + static_assert(IsSame<decltype(opt), Optional<int>>::value); + static_assert(IsSame<decltype(dupe), Optional<int>>::value); + static_assert(!IsSame<decltype(dupe), Optional<Optional<int>>>::value); + return 0; +} + + +}
\ No newline at end of file diff --git a/test/CXX/special/class.dtor/p5-implicit.cpp b/test/CXX/special/class.dtor/p5-implicit.cpp new file mode 100644 index 000000000000..703be15b70cd --- /dev/null +++ b/test/CXX/special/class.dtor/p5-implicit.cpp @@ -0,0 +1,21 @@ +// RUN: %clang_cc1 -std=c++11 %s -ast-dump | FileCheck %s + +struct A { ~A() = delete; }; +// CHECK-LABEL: CXXRecordDecl {{.*}} struct A +// CHECK: Destructor trivial user_declared + +struct B : A {}; +// CHECK-LABEL: CXXRecordDecl {{.*}} struct B +// CHECK: Destructor trivial needs_overload_resolution + +struct C : B {}; +// CHECK-LABEL: CXXRecordDecl {{.*}} struct C +// CHECK: Destructor trivial needs_overload_resolution + +struct D { ~D(); }; +struct E : D {}; +union U { + E e; +}; +// CHECK-LABEL: CXXRecordDecl {{.*}} union U +// CHECK: Destructor non_trivial needs_implicit defaulted_is_deleted diff --git a/test/CXX/temp/temp.decls/temp.variadic/p4.cpp b/test/CXX/temp/temp.decls/temp.variadic/p4.cpp index d8294a1f154a..1681325f2e6c 100644 --- a/test/CXX/temp/temp.decls/temp.variadic/p4.cpp +++ b/test/CXX/temp/temp.decls/temp.variadic/p4.cpp @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -std=c++11 -fsyntax-only -fexceptions -fcxx-exceptions -verify %s +// RUN: %clang_cc1 -std=c++2a -fsyntax-only -fexceptions -fcxx-exceptions -verify %s template<typename... Types> struct tuple; template<int I> struct int_c; @@ -174,6 +175,7 @@ int check_temp_arg_1[is_same<tuple_of_ints<1, 2, 3, 4, 5>::type, tuple<int_c<1>, int_c<2>, int_c<3>, int_c<4>, int_c<5>>>::value? 1 : -1]; +#if __cplusplus < 201703L // In a dynamic-exception-specification (15.4); the pattern is a type-id. template<typename ...Types> struct f_with_except { @@ -191,3 +193,99 @@ struct check_f_with_except_2 : f_with_except<int, float> { struct check_f_with_except_3 : f_with_except<int, float> { virtual void f() throw(int, float, double); // expected-error{{exception specification of overriding function is more lax than base version}} }; +#endif + +namespace PackExpansionWithinLambda { + void swallow(...); + template<typename ...T, typename ...U> void f(U ...u) { + swallow([=] { + // C++17 [temp.variadic]p4: + // Pack expansions can occur in the following contexts: + + // - in a function parameter pack + void g(T...); + +#if __cplusplus >= 201703L + struct A : T... { + // - in a using-declaration + using T::x...; + using typename T::U...; + }; +#endif + + // - in a template parameter pack that is a pack expansion + // FIXME: We do not support any way to reach this case yet. + + // - in an initializer-list + int arr[] = {T().x...}; + + // - in a base-specifier-list + struct B : T... { + // - in a mem-initializer-list + B() : T{0}... {} + }; + + // - in a template-argument-list + f<T...>(); + + // - in an attribute-list + // FIXME: We do not support any such attributes yet. + + // - in an alignment-specifier + alignas(T...) int y; + + // - in a capture-list + [](T ...t) { [t...]{}(); } (T()...); + + // - in a sizeof... expression + const int k1 = sizeof...(T); + +#if __cplusplus >= 201703L + // - in a fold-expression + const int k2 = ((sizeof(T)/sizeof(T)) + ...); + + static_assert(k1 == k2); +#endif + + // Trigger clang to look in here for unexpanded packs. + U u; + } ...); + } + + template<typename ...T> void nested() { + swallow([=] { + [](T ...t) { [t]{}(); } (T()...); // expected-error {{unexpanded parameter pack 't'}} + }...); // expected-error {{does not contain any unexpanded}} + } + + template <typename ...T> void g() { + // Check that we do detect the above cases when the pack is not expanded. + swallow([=] { void h(T); }); // expected-error {{unexpanded parameter pack 'T'}} + swallow([=] { struct A : T {}; }); // expected-error {{unexpanded parameter pack 'T'}} +#if __cplusplus >= 201703L + swallow([=] { struct A : T... { using T::x; }; }); // expected-error {{unexpanded parameter pack 'T'}} + swallow([=] { struct A : T... { using typename T::U; }; }); // expected-error {{unexpanded parameter pack 'T'}} +#endif + + swallow([=] { int arr[] = {T().x}; }); // expected-error {{unexpanded parameter pack 'T'}} + swallow([=] { struct B : T... { B() : T{0} {} }; }); // expected-error {{unexpanded parameter pack 'T'}} + swallow([=] { f<T>(); }); // expected-error {{unexpanded parameter pack 'T'}} + swallow([=] { alignas(T) int y; }); // expected-error {{unexpanded parameter pack 'T'}} + swallow([=] { [](T ...t) { + [t]{}(); // expected-error {{unexpanded parameter pack 't'}} + } (T()...); }); + } + + struct T { int x; using U = int; }; + void g() { f<T>(1, 2, 3); } + + template<typename ...T, typename ...U> void pack_in_lambda(U ...u) { // expected-note {{here}} + // FIXME: Move this test into 'f' above once we support this syntax. + []<T *...v, template<T *> typename ...U>(U<v> ...uv) {}; // expected-error {{expected body of lambda}} expected-error {{does not refer to a value}} + } + + template<typename ...T> void pack_expand_attr() { + // FIXME: Move this test into 'f' above once we support this. + [[gnu::aligned(alignof(T))...]] int x; // expected-error {{cannot be used as an attribute pack}} expected-error {{unexpanded}} + } +} |