mizvekov updated this revision to Diff 355714.
mizvekov added a comment.
- fix test diagnostic expectation using regular expressions.
Repository:
rG LLVM Github Monorepo
CHANGES SINCE LAST ACTION
https://reviews.llvm.org/D104500/new/
https://reviews.llvm.org/D104500
Files:
clang/include/clang/Basic/DiagnosticSemaKinds.td
clang/include/clang/Sema/Sema.h
clang/lib/Sema/SemaStmt.cpp
clang/test/CXX/class/class.init/class.copy.elision/p3.cpp
clang/test/SemaCXX/P1155.cpp
clang/test/SemaCXX/conversion-function.cpp
clang/test/SemaCXX/warn-return-std-move.cpp
clang/test/SemaObjCXX/block-capture.mm
Index: clang/test/SemaObjCXX/block-capture.mm
===================================================================
--- clang/test/SemaObjCXX/block-capture.mm
+++ clang/test/SemaObjCXX/block-capture.mm
@@ -1,7 +1,7 @@
-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx20_2b,cxx2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx20_2b %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx98_11 %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b,cxx98_11 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx11_2b,cxx2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx11_2b %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fobjc-arc -fblocks -verify=cxx98_2b,cxx11_2b %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fobjc-arc -fblocks -Wno-c++11-extensions -verify=cxx98_2b,cxx98 %s
#define TEST(T) void test_##T() { \
__block T x; \
@@ -14,54 +14,68 @@
};
TEST(CopyOnly); // cxx2b-error {{no matching constructor}}
+struct ConstCopyOnly {
+ ConstCopyOnly();
+ ConstCopyOnly(ConstCopyOnly &) = delete; // cxx98-note {{marked deleted here}}
+ ConstCopyOnly(const ConstCopyOnly &);
+};
+TEST(ConstCopyOnly); // cxx98-error {{call to deleted constructor}}
+
+struct NonConstCopyOnly {
+ NonConstCopyOnly();
+ NonConstCopyOnly(NonConstCopyOnly &);
+ NonConstCopyOnly(const NonConstCopyOnly &) = delete; // cxx11_2b-note {{marked deleted here}}
+};
+TEST(NonConstCopyOnly); // cxx11_2b-error {{call to deleted constructor}}
+
struct CopyNoMove {
CopyNoMove();
CopyNoMove(CopyNoMove &);
- CopyNoMove(CopyNoMove &&) = delete; // cxx98_2b-note {{marked deleted here}}
+ CopyNoMove(CopyNoMove &&) = delete; // cxx11_2b-note {{marked deleted here}}
};
-TEST(CopyNoMove); // cxx98_2b-error {{call to deleted constructor}}
+TEST(CopyNoMove); // cxx11_2b-error {{call to deleted constructor}}
struct MoveOnly {
MoveOnly();
- MoveOnly(MoveOnly &) = delete;
+ MoveOnly(MoveOnly &) = delete; // cxx98-note {{marked deleted here}}
MoveOnly(MoveOnly &&);
};
-TEST(MoveOnly);
+TEST(MoveOnly); // cxx98-error {{call to deleted constructor}}
struct NoCopyNoMove {
NoCopyNoMove();
- NoCopyNoMove(NoCopyNoMove &) = delete;
- NoCopyNoMove(NoCopyNoMove &&) = delete; // cxx98_2b-note {{marked deleted here}}
+ NoCopyNoMove(NoCopyNoMove &) = delete; // cxx98-note {{marked deleted here}}
+ NoCopyNoMove(NoCopyNoMove &&) = delete; // cxx11_2b-note {{marked deleted here}}
};
TEST(NoCopyNoMove); // cxx98_2b-error {{call to deleted constructor}}
struct ConvertingRVRef {
ConvertingRVRef();
- ConvertingRVRef(ConvertingRVRef &) = delete; // cxx98_11-note {{marked deleted here}}
+ ConvertingRVRef(ConvertingRVRef &) = delete; // cxx98-note {{marked deleted here}}
struct X {};
ConvertingRVRef(X &&);
operator X() const & = delete;
operator X() &&;
};
-TEST(ConvertingRVRef); // cxx98_11-error {{call to deleted constructor}}
+TEST(ConvertingRVRef); // cxx98-error {{call to deleted constructor}}
struct ConvertingCLVRef {
ConvertingCLVRef();
ConvertingCLVRef(ConvertingCLVRef &);
struct X {};
- ConvertingCLVRef(X &&); // cxx20_2b-note {{passing argument to parameter here}}
+ ConvertingCLVRef(X &&); // cxx11_2b-note {{passing argument to parameter here}}
operator X() const &;
- operator X() && = delete; // cxx20_2b-note {{marked deleted here}}
+ operator X() && = delete; // cxx11_2b-note {{marked deleted here}}
};
-TEST(ConvertingCLVRef); // cxx20_2b-error {{invokes a deleted function}}
+TEST(ConvertingCLVRef); // cxx11_2b-error {{invokes a deleted function}}
struct SubSubMove {};
struct SubMove : SubSubMove {
SubMove();
- SubMove(SubMove &) = delete; // cxx98_11-note {{marked deleted here}}
+ SubMove(SubMove &) = delete; // cxx98-note {{marked deleted here}}
SubMove(SubSubMove &&);
};
-TEST(SubMove); // cxx98_11-error {{call to deleted constructor}}
+TEST(SubMove); // cxx98-error {{call to deleted constructor}}
Index: clang/test/SemaCXX/warn-return-std-move.cpp
===================================================================
--- clang/test/SemaCXX/warn-return-std-move.cpp
+++ /dev/null
@@ -1,351 +0,0 @@
-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=cxx20_2b,cxx2b -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=cxx20_2b -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=cxx11_17 -fcxx-exceptions -Wreturn-std-move %s
-
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -Wreturn-std-move -fdiagnostics-parseable-fixits %s 2>&1 | FileCheck %s -check-prefix=CHECK
-
-// definitions for std::move
-namespace std {
-inline namespace foo {
-template <class T> struct remove_reference { typedef T type; };
-template <class T> struct remove_reference<T &> { typedef T type; };
-template <class T> struct remove_reference<T &&> { typedef T type; };
-
-template <class T> typename remove_reference<T>::type &&move(T &&t);
-} // namespace foo
-} // namespace std
-
-struct Instrument {
- Instrument() {}
- Instrument(Instrument&&) { /* MOVE */ }
- Instrument(const Instrument&) { /* COPY */ }
-};
-struct ConvertFromBase { Instrument i; };
-struct ConvertFromDerived { Instrument i; };
-struct Base {
- Instrument i;
- operator ConvertFromBase() const& { return ConvertFromBase{i}; }
- operator ConvertFromBase() && { return ConvertFromBase{std::move(i)}; }
-};
-struct Derived : public Base {
- operator ConvertFromDerived() const& { return ConvertFromDerived{i}; }
- operator ConvertFromDerived() && { return ConvertFromDerived{std::move(i)}; }
-};
-struct ConstructFromBase {
- Instrument i;
- ConstructFromBase(const Base& b): i(b.i) {}
- ConstructFromBase(Base&& b): i(std::move(b.i)) {}
-};
-struct ConstructFromDerived {
- Instrument i;
- ConstructFromDerived(const Derived& d): i(d.i) {}
- ConstructFromDerived(Derived&& d): i(std::move(d.i)) {}
-};
-
-struct TrivialInstrument {
- int i = 42;
-};
-struct ConvertFromTrivialBase { TrivialInstrument i; };
-struct ConvertFromTrivialDerived { TrivialInstrument i; };
-struct TrivialBase {
- TrivialInstrument i;
- operator ConvertFromTrivialBase() const& { return ConvertFromTrivialBase{i}; }
- operator ConvertFromTrivialBase() && { return ConvertFromTrivialBase{std::move(i)}; }
-};
-struct TrivialDerived : public TrivialBase {
- operator ConvertFromTrivialDerived() const& { return ConvertFromTrivialDerived{i}; }
- operator ConvertFromTrivialDerived() && { return ConvertFromTrivialDerived{std::move(i)}; }
-};
-struct ConstructFromTrivialBase {
- TrivialInstrument i;
- ConstructFromTrivialBase(const TrivialBase& b): i(b.i) {}
- ConstructFromTrivialBase(TrivialBase&& b): i(std::move(b.i)) {}
-};
-struct ConstructFromTrivialDerived {
- TrivialInstrument i;
- ConstructFromTrivialDerived(const TrivialDerived& d): i(d.i) {}
- ConstructFromTrivialDerived(TrivialDerived&& d): i(std::move(d.i)) {}
-};
-
-Derived test1() {
- Derived d1;
- return d1; // ok
-}
-Base test2() {
- Derived d2;
- return d2; // e1
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d2)"
-}
-ConstructFromDerived test3() {
- Derived d3;
- return d3; // ok
-}
-ConstructFromBase test4() {
- Derived d4;
- return d4; // e3
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d4)"
-}
-ConvertFromDerived test5() {
- Derived d5;
- return d5; // e4
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d5)"
-}
-ConvertFromBase test6() {
- Derived d6;
- return d6; // e5
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:14}:"std::move(d6)"
-}
-
-// These test cases should not produce the warning.
-Derived ok1() { Derived d; return d; }
-Base ok2() { Derived d; return static_cast<Derived&&>(d); }
-ConstructFromDerived ok3() { Derived d; return static_cast<Derived&&>(d); }
-ConstructFromBase ok4() { Derived d; return static_cast<Derived&&>(d); }
-ConvertFromDerived ok5() { Derived d; return static_cast<Derived&&>(d); }
-ConvertFromBase ok6() { Derived d; return static_cast<Derived&&>(d); }
-
-// If the target is an lvalue reference, assume it's not safe to move from.
-Derived ok_plvalue1(Derived& d) { return d; }
-Base ok_plvalue2(Derived& d) { return d; }
-ConstructFromDerived ok_plvalue3(const Derived& d) { return d; }
-ConstructFromBase ok_plvalue4(Derived& d) { return d; }
-ConvertFromDerived ok_plvalue5(Derived& d) { return d; }
-ConvertFromBase ok_plvalue6(Derived& d) { return d; }
-
-Derived ok_lvalue1(Derived *p) { Derived& d = *p; return d; }
-Base ok_lvalue2(Derived *p) { Derived& d = *p; return d; }
-ConstructFromDerived ok_lvalue3(Derived *p) { const Derived& d = *p; return d; }
-ConstructFromBase ok_lvalue4(Derived *p) { Derived& d = *p; return d; }
-ConvertFromDerived ok_lvalue5(Derived *p) { Derived& d = *p; return d; }
-ConvertFromBase ok_lvalue6(Derived *p) { Derived& d = *p; return d; }
-
-// If the target is a global, assume it's not safe to move from.
-static Derived global_d;
-Derived ok_global1() { return global_d; }
-Base ok_global2() { return global_d; }
-ConstructFromDerived ok_global3() { return global_d; }
-ConstructFromBase ok_global4() { return global_d; }
-ConvertFromDerived ok_global5() { return global_d; }
-ConvertFromBase ok_global6() { return global_d; }
-
-// If the target's copy constructor is trivial, assume the programmer doesn't care.
-TrivialDerived ok_trivial1(TrivialDerived d) { return d; }
-TrivialBase ok_trivial2(TrivialDerived d) { return d; }
-ConstructFromTrivialDerived ok_trivial3(TrivialDerived d) { return d; }
-ConstructFromTrivialBase ok_trivial4(TrivialDerived d) { return d; }
-ConvertFromTrivialDerived ok_trivial5(TrivialDerived d) { return d; }
-ConvertFromTrivialBase ok_trivial6(TrivialDerived d) { return d; }
-
-// If the target is a parameter, do apply the diagnostic.
-Derived testParam1(Derived d) { return d; }
-Base testParam2(Derived d) {
- return d; // e6
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConstructFromDerived testParam3(Derived d) {
- return d; // ok
-}
-ConstructFromBase testParam4(Derived d) {
- return d; // e8
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConvertFromDerived testParam5(Derived d) {
- return d; // e9
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConvertFromBase testParam6(Derived d) {
- return d; // e10
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-
-// If the target is an rvalue reference parameter, do apply the diagnostic.
-Derived testRParam1(Derived&& d) {
- return d; // e11
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-Base testRParam2(Derived&& d) {
- return d; // e12
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConstructFromDerived testRParam3(Derived&& d) {
- return d; // e13
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConstructFromBase testRParam4(Derived&& d) {
- return d; // e14
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConvertFromDerived testRParam5(Derived&& d) {
- return d; // e15
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-ConvertFromBase testRParam6(Derived&& d) {
- return d; // e16
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:13}:"std::move(d)"
-}
-
-// But if the return type is a reference type, then moving would be wrong.
-Derived &testRetRef1(Derived &&d) { return d; } // cxx2b-error {{non-const lvalue reference to type 'Derived' cannot bind to a temporary of type 'Derived'}}
-Base &testRetRef2(Derived &&d) { return d; } // cxx2b-error {{non-const lvalue reference to type 'Base' cannot bind to a temporary of type 'Derived'}}
-#if __cplusplus >= 201402L
-auto&& testRetRef3(Derived&& d) { return d; }
-decltype(auto) testRetRef4(Derived&& d) { return (d); }
-#endif
-
-// As long as we're checking parentheses, make sure parentheses don't disable the warning.
-Base testParens1() {
- Derived d;
- return (d); // e17
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:12-[[@LINE-3]]:15}:"std::move(d)"
-}
-ConstructFromDerived testParens2() {
- Derived d;
- return (d); // ok
-}
-
-// If the target is a catch-handler parameter, do apply the diagnostic.
-void throw_derived();
-Derived testEParam1() {
- try { throw_derived(); } catch (Derived d) { return d; } // e19
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
- __builtin_unreachable();
-}
-Base testEParam2() {
- try { throw_derived(); } catch (Derived d) { return d; } // e20
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
- __builtin_unreachable();
-}
-ConstructFromDerived testEParam3() {
- try { throw_derived(); } catch (Derived d) { return d; } // e21
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
- __builtin_unreachable();
-}
-ConstructFromBase testEParam4() {
- try { throw_derived(); } catch (Derived d) { return d; } // e22
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
- __builtin_unreachable();
-}
-ConvertFromDerived testEParam5() {
- try { throw_derived(); } catch (Derived d) { return d; } // e23
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
- __builtin_unreachable();
-}
-ConvertFromBase testEParam6() {
- try { throw_derived(); } catch (Derived d) { return d; } // e24
- // cxx11_17-warning@-1{{will be copied despite being returned by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:57-[[@LINE-3]]:58}:"std::move(d)"
- __builtin_unreachable();
-}
-
-// If the exception variable is an lvalue reference, we cannot be sure
-// that we own it; it is extremely contrived, but possible, for this to
-// be a reference to an exception object that was thrown via
-// `std::rethrow_exception(xp)` in Thread A, and meanwhile somebody else
-// has got a copy of `xp` in Thread B, so that moving out of this object
-// in Thread A would be observable (and racy) with respect to Thread B.
-// Therefore assume it's not safe to move from.
-Derived ok_REParam1() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-Base ok_REParam2() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromDerived ok_REParam3() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromBase ok_REParam4() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromDerived ok_REParam5() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromBase ok_REParam6() { try { throw_derived(); } catch (Derived& d) { return d; } __builtin_unreachable(); }
-
-Derived ok_CEParam1() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-Base ok_CEParam2() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromDerived ok_CEParam3() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConstructFromBase ok_CEParam4() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromDerived ok_CEParam5() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-ConvertFromBase ok_CEParam6() { try { throw_derived(); } catch (const Derived& d) { return d; } __builtin_unreachable(); }
-
-// If rvalue overload resolution would find a copy constructor anyway,
-// or if the copy constructor actually selected is trivial, then don't warn.
-struct TriviallyCopyable {};
-struct OnlyCopyable {
- OnlyCopyable() = default;
- OnlyCopyable(const OnlyCopyable&) {}
-};
-
-TriviallyCopyable ok_copy1() { TriviallyCopyable c; return c; }
-OnlyCopyable ok_copy2() { OnlyCopyable c; return c; }
-TriviallyCopyable ok_copyparam1(TriviallyCopyable c) { return c; }
-OnlyCopyable ok_copyparam2(OnlyCopyable c) { return c; }
-
-void test_throw1(Derived&& d) {
- throw d; // e25
- // cxx11_17-warning@-1{{will be copied despite being thrown by name}}
- // cxx11_17-note@-2{{to avoid copying}}
- // CHECK: fix-it:"{{.*}}":{[[@LINE-3]]:11-[[@LINE-3]]:12}:"std::move(d)"
-}
-
-void ok_throw1() {
- Derived d;
- throw d;
-}
-void ok_throw2(Derived d) { throw d; }
-void ok_throw3(Derived &d) { throw d; }
-void ok_throw4(Derived d) { throw std::move(d); }
-void ok_throw5(Derived &d) { throw std::move(d); }
-void ok_throw6(Derived &d) { throw static_cast<Derived &&>(d); }
-void ok_throw7(TriviallyCopyable d) { throw d; }
-void ok_throw8(OnlyCopyable d) { throw d; }
-
-namespace test_delete {
-struct Base {
- Base();
- Base(Base &&) = delete; // cxx20_2b-note {{'Base' has been explicitly marked deleted here}}
- Base(Base const &);
-};
-
-struct Derived : public Base {};
-
-Base test_ok() {
- Derived d;
- return d; // cxx20_2b-error {{call to deleted constructor of 'test_delete::Base'}}
-}
-} // namespace test_delete
Index: clang/test/SemaCXX/conversion-function.cpp
===================================================================
--- clang/test/SemaCXX/conversion-function.cpp
+++ clang/test/SemaCXX/conversion-function.cpp
@@ -1,9 +1,7 @@
-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
-// RUN: %clang_cc1 -fsyntax-only -verify=expected,cxx98_14 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -verify=expected -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify=expected,cxx98_11,cxx11 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -verify=expected,cxx98_11,cxx98 -triple %itanium_abi_triple -Wbind-to-temporary-copy %s
class X {
public:
@@ -126,7 +124,7 @@
class AutoPtrRef { };
class AutoPtr {
- AutoPtr(AutoPtr &); // cxx98_14-note{{declared private here}}
+ AutoPtr(AutoPtr &); // cxx98-note {{declared private here}}
public:
AutoPtr();
@@ -142,7 +140,7 @@
AutoPtr p;
if (Cond)
- return p; // cxx98_14-error{{calling a private constructor}}
+ return p; // cxx98-error {{calling a private constructor}}
return AutoPtr();
}
@@ -152,17 +150,14 @@
~A1();
private:
- A1(const A1&); // cxx98_14-note 2 {{declared private here}}
+ A1(const A1 &); // cxx98_11-note 2 {{declared private here}}
};
A1 f() {
// FIXME: redundant diagnostics!
- return "Hello"; // cxx98_14-error {{calling a private constructor}}
-#if __cplusplus <= 199711L
- // expected-warning@-2 {{an accessible copy constructor}}
-#else
- // cxx98_14-warning@-4 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
-#endif
+ return "Hello"; // cxx98_11-error {{calling a private constructor}}
+ // cxx98-warning@-1 {{an accessible copy constructor}}
+ // cxx11-warning@-2 {{copying parameter of type 'A1' when binding a reference to a temporary would invoke an inaccessible constructor in C++98}}
}
namespace source_locations {
Index: clang/test/SemaCXX/P1155.cpp
===================================================================
--- clang/test/SemaCXX/P1155.cpp
+++ clang/test/SemaCXX/P1155.cpp
@@ -1,9 +1,7 @@
-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=cxx20_2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=cxx20_2b %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=cxx11_17 %s
-// cxx20_2b-no-diagnostics
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify %s
+// expected-no-diagnostics
// Throwing
namespace test_throwing {
@@ -14,7 +12,7 @@
};
void seven(Widget w) {
- throw w; // Clang already do this implicit move before -std=c++20
+ throw w;
}
} // namespace test_throwing
@@ -23,13 +21,13 @@
class Widget {};
struct To {
- operator Widget() const & = delete; // cxx11_17-note {{'operator Widget' has been explicitly marked deleted here}}
+ operator Widget() const & = delete;
operator Widget() &&;
};
Widget nine() {
To t;
- return t; // cxx11_17-error {{conversion function from 'test_non_constructor_conversion::To' to 'test_non_constructor_conversion::Widget' invokes a deleted function}}
+ return t;
}
} // namespace test_non_constructor_conversion
@@ -39,16 +37,16 @@
public:
Widget();
Widget(Widget &&);
- Widget(const Widget &) = delete; // cxx11_17-note {{'Widget' has been explicitly marked deleted here}}
+ Widget(const Widget &) = delete;
};
struct Fowl {
- Fowl(Widget); // cxx11_17-note {{passing argument to parameter here}}
+ Fowl(Widget);
};
Fowl eleven() {
Widget w;
- return w; // cxx11_17-error {{call to deleted constructor of 'test_by_value_sinks::Widget'}}
+ return w;
}
} // namespace test_by_value_sinks
@@ -58,13 +56,13 @@
public:
Base();
Base(Base &&);
- Base(Base const &) = delete; // cxx11_17-note {{'Base' has been explicitly marked deleted here}}
+ Base(Base const &) = delete;
};
class Derived : public Base {};
Base thirteen() {
Derived result;
- return result; // cxx11_17-error {{call to deleted constructor of 'test_slicing::Base'}}
+ return result;
}
} // namespace test_slicing
Index: clang/test/CXX/class/class.init/class.copy.elision/p3.cpp
===================================================================
--- clang/test/CXX/class/class.init/class.copy.elision/p3.cpp
+++ clang/test/CXX/class/class.init/class.copy.elision/p3.cpp
@@ -1,18 +1,17 @@
-// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx20_2b,cxx2b %s
-// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_20,cxx20_2b %s
-// RUN: %clang_cc1 -std=c++17 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17,cxx11_20 %s
-// RUN: %clang_cc1 -std=c++14 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17,cxx11_20 %s
-// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_17,cxx11_20 %s
+// RUN: %clang_cc1 -std=c++2b -fsyntax-only -fcxx-exceptions -verify=expected,cxx11_2b,cxx2b %s
+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -fcxx-exceptions -verify=expected,cxx98_20,cxx11_2b,cxx11_20 %s
+// RUN: %clang_cc1 -std=c++11 -fsyntax-only -fcxx-exceptions -verify=expected,cxx98_20,cxx11_2b,cxx11_20 %s
+// RUN: %clang_cc1 -std=c++98 -fsyntax-only -fcxx-exceptions -Wno-c++11-extensions -verify=expected,cxx98_20,cxx98 %s
namespace test_delete_function {
struct A1 {
A1();
A1(const A1 &);
- A1(A1 &&) = delete; // expected-note {{'A1' has been explicitly marked deleted here}}
+ A1(A1 &&) = delete; // cxx11_2b-note {{'A1' has been explicitly marked deleted here}}
};
A1 test1() {
A1 a;
- return a; // expected-error {{call to deleted constructor of 'test_delete_function::A1'}}
+ return a; // cxx11_2b-error {{call to deleted constructor of 'test_delete_function::A1'}}
}
struct A2 {
@@ -20,91 +19,90 @@
A2(const A2 &);
private:
- A2(A2 &&); // expected-note {{declared private here}}
+ A2(A2 &&); // cxx11_2b-note {{declared private here}}
};
A2 test2() {
A2 a;
- return a; // expected-error {{calling a private constructor of class 'test_delete_function::A2'}}
+ return a; // cxx11_2b-error {{calling a private constructor of class 'test_delete_function::A2'}}
}
struct C {};
struct B1 {
B1(C &);
- B1(C &&) = delete; // expected-note {{'B1' has been explicitly marked deleted here}}
+ B1(C &&) = delete; // cxx11_2b-note {{'B1' has been explicitly marked deleted here}}
};
B1 test3() {
C c;
- return c; // expected-error {{conversion function from 'test_delete_function::C' to 'test_delete_function::B1' invokes a deleted function}}
+ return c; // cxx11_2b-error {{conversion function from 'test_delete_function::C' to 'test_delete_function::B1' invokes a deleted function}}
}
struct B2 {
B2(C &);
private:
- B2(C &&); // expected-note {{declared private here}}
+ B2(C &&); // cxx11_2b-note {{declared private here}}
};
B2 test4() {
C c;
- return c; // expected-error {{calling a private constructor of class 'test_delete_function::B2'}}
+ return c; // cxx11_2b-error {{calling a private constructor of class 'test_delete_function::B2'}}
}
} // namespace test_delete_function
-// In C++20, implicitly movable entity can be rvalue reference to non-volatile
+// Implicitly movable entity can be rvalue reference to non-volatile
// automatic object.
namespace test_implicitly_movable_rvalue_ref {
struct A1 {
A1(A1 &&);
- A1(const A1 &) = delete; // cxx11_17-note {{'A1' has been explicitly marked deleted here}}
+ A1(const A1 &) = delete; // cxx98-note {{marked deleted here}}
};
A1 test1(A1 &&a) {
- return a; // cxx11_17-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::A1'}}
+ return a; // cxx98-error {{call to deleted constructor}}
}
struct A2 {
A2(A2 &&);
private:
- A2(const A2 &); // cxx11_17-note {{declared private here}}
+ A2(const A2 &); // cxx98-note {{declared private here}}
};
A2 test2(A2 &&a) {
- return a; // cxx11_17-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::A2'}}
+ return a; // cxx98-error {{calling a private constructor}}
}
struct B1 {
B1(const B1 &);
- B1(B1 &&) = delete; // cxx20_2b-note {{'B1' has been explicitly marked deleted here}}
+ B1(B1 &&) = delete; // cxx11_2b-note {{'B1' has been explicitly marked deleted here}}
};
B1 test3(B1 &&b) {
- return b; // cxx20_2b-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
+ return b; // cxx11_2b-error {{call to deleted constructor of 'test_implicitly_movable_rvalue_ref::B1'}}
}
struct B2 {
B2(const B2 &);
private:
- B2(B2 &&); // cxx20_2b-note {{declared private here}}
+ B2(B2 &&); // cxx11_2b-note {{declared private here}}
};
B2 test4(B2 &&b) {
- return b; // cxx20_2b-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::B2'}}
+ return b; // cxx11_2b-error {{calling a private constructor of class 'test_implicitly_movable_rvalue_ref::B2'}}
}
} // namespace test_implicitly_movable_rvalue_ref
-// In C++20, operand of throw-expression can be function parameter or
+// Operand of throw-expression can be function parameter or
// catch-clause parameter.
namespace test_throw_parameter {
void func();
struct A1 {
A1(const A1 &);
- A1(A1 &&) = delete; // cxx20_2b-note {{'A1' has been explicitly marked deleted here}}
- // expected-note@-1 {{'A1' has been explicitly marked deleted here}}
+ A1(A1 &&) = delete; // cxx11_2b-note 2{{'A1' has been explicitly marked deleted here}}
};
void test1() {
try {
func();
} catch (A1 a) {
- throw a; // cxx20_2b-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
+ throw a; // cxx11_2b-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
}
}
@@ -112,70 +110,70 @@
A2(const A2 &);
private:
- A2(A2 &&); // cxx20_2b-note {{declared private here}}
+ A2(A2 &&); // cxx11_2b-note {{declared private here}}
};
void test2() {
try {
func();
} catch (A2 a) {
- throw a; // cxx20_2b-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
+ throw a; // cxx11_2b-error {{calling a private constructor of class 'test_throw_parameter::A2'}}
}
}
void test3(A1 a) try {
func();
} catch (...) {
- throw a; // expected-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
+ throw a; // cxx11_2b-error {{call to deleted constructor of 'test_throw_parameter::A1'}}
}
} // namespace test_throw_parameter
-// In C++20, during the first overload resolution, the selected function no
+// During the first overload resolution, the selected function no
// need to be a constructor.
namespace test_non_ctor_conversion {
class C {};
struct A1 {
operator C() &&;
- operator C() const & = delete; // cxx11_17-note {{'operator C' has been explicitly marked deleted here}}
+ operator C() const & = delete; // cxx98-note {{marked deleted here}}
};
C test1() {
A1 a;
- return a; // cxx11_17-error {{conversion function from 'test_non_ctor_conversion::A1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+ return a; // cxx98-error {{invokes a deleted function}}
}
struct A2 {
operator C() &&;
private:
- operator C() const &; // cxx11_17-note {{declared private here}}
+ operator C() const &; // cxx98-note {{declared private here}}
};
C test2() {
A2 a;
- return a; // cxx11_17-error {{'operator C' is a private member of 'test_non_ctor_conversion::A2'}}
+ return a; // cxx98-error {{'operator C' is a private member}}
}
struct B1 {
operator C() const &;
- operator C() && = delete; // cxx20_2b-note {{'operator C' has been explicitly marked deleted here}}
+ operator C() && = delete; // cxx11_2b-note {{'operator C' has been explicitly marked deleted here}}
};
C test3() {
B1 b;
- return b; // cxx20_2b-error {{conversion function from 'test_non_ctor_conversion::B1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
+ return b; // cxx11_2b-error {{conversion function from 'test_non_ctor_conversion::B1' to 'test_non_ctor_conversion::C' invokes a deleted function}}
}
struct B2 {
operator C() const &;
private:
- operator C() &&; // cxx20_2b-note {{declared private here}}
+ operator C() &&; // cxx11_2b-note {{declared private here}}
};
C test4() {
B2 b;
- return b; // cxx20_2b-error {{'operator C' is a private member of 'test_non_ctor_conversion::B2'}}
+ return b; // cxx11_2b-error {{'operator C' is a private member of 'test_non_ctor_conversion::B2'}}
}
} // namespace test_non_ctor_conversion
-// In C++20, during the first overload resolution, the first parameter of the
+// During the first overload resolution, the first parameter of the
// selected function no need to be an rvalue reference to the object's type.
namespace test_ctor_param_rvalue_ref {
struct A1;
@@ -190,35 +188,35 @@
NeedRvalueRef(B2 &&);
};
struct NeedValue {
- NeedValue(A1); // cxx11_17-note 2 {{passing argument to parameter here}}
+ NeedValue(A1); // cxx98-note 2 {{passing argument to parameter here}}
NeedValue(A2);
- NeedValue(B1); // cxx20_2b-note 2 {{passing argument to parameter here}}
+ NeedValue(B1); // cxx11_2b-note 2 {{passing argument to parameter here}}
NeedValue(B2);
};
struct A1 {
A1();
A1(A1 &&);
- A1(const A1 &) = delete; // cxx11_17-note 3 {{'A1' has been explicitly marked deleted here}}
+ A1(const A1 &) = delete; // cxx98-note 3{{marked deleted here}}
};
NeedValue test_1_1() {
// not rvalue reference
// same type
A1 a;
- return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+ return a; // cxx98-error {{call to deleted constructor}}
}
class DerivedA1 : public A1 {};
A1 test_1_2() {
// rvalue reference
// not same type
DerivedA1 a;
- return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+ return a; // cxx98-error {{call to deleted constructor}}
}
NeedValue test_1_3() {
// not rvalue reference
// not same type
DerivedA1 a;
- return a; // cxx11_17-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::A1'}}
+ return a; // cxx98-error {{call to deleted constructor}}
}
struct A2 {
@@ -226,51 +224,51 @@
A2(A2 &&);
private:
- A2(const A2 &); // cxx11_17-note 3 {{declared private here}}
+ A2(const A2 &); // cxx98-note 3{{declared private here}}
};
NeedValue test_2_1() {
// not rvalue reference
// same type
A2 a;
- return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+ return a; // cxx98-error {{calling a private constructor}}
}
class DerivedA2 : public A2 {};
A2 test_2_2() {
// rvalue reference
// not same type
DerivedA2 a;
- return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+ return a; // cxx98-error {{calling a private constructor}}
}
NeedValue test_2_3() {
// not rvalue reference
// not same type
DerivedA2 a;
- return a; // cxx11_17-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::A2'}}
+ return a; // cxx98-error {{calling a private constructor}}
}
struct B1 {
B1();
B1(const B1 &);
- B1(B1 &&) = delete; // cxx20_2b-note 3 {{'B1' has been explicitly marked deleted here}}
+ B1(B1 &&) = delete; // cxx11_2b-note 3 {{'B1' has been explicitly marked deleted here}}
};
NeedValue test_3_1() {
// not rvalue reference
// same type
B1 b;
- return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+ return b; // cxx11_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
}
class DerivedB1 : public B1 {};
B1 test_3_2() {
// rvalue reference
// not same type
DerivedB1 b;
- return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+ return b; // cxx11_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
}
NeedValue test_3_3() {
// not rvalue reference
// not same type
DerivedB1 b;
- return b; // cxx20_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
+ return b; // cxx11_2b-error {{call to deleted constructor of 'test_ctor_param_rvalue_ref::B1'}}
}
struct B2 {
@@ -278,49 +276,46 @@
B2(const B2 &);
private:
- B2(B2 &&); // cxx20_2b-note 3 {{declared private here}}
+ B2(B2 &&); // cxx11_2b-note 3 {{declared private here}}
};
NeedValue test_4_1() {
// not rvalue reference
// same type
B2 b;
- return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+ return b; // cxx11_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
}
class DerivedB2 : public B2 {};
B2 test_4_2() {
// rvalue reference
// not same type
DerivedB2 b;
- return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+ return b; // cxx11_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
}
NeedValue test_4_3() {
// not rvalue reference
// not same type
DerivedB2 b;
- return b; // cxx20_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
+ return b; // cxx11_2b-error {{calling a private constructor of class 'test_ctor_param_rvalue_ref::B2'}}
}
} // namespace test_ctor_param_rvalue_ref
namespace test_lvalue_ref_is_not_moved_from {
struct Target {};
- // expected-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
- // expected-note@-2 {{candidate constructor (the implicit move constructor) not viable}}
- // cxx11_17-note@-3 {{candidate constructor (the implicit copy constructor) not viable}}
- // cxx11_17-note@-4 {{candidate constructor (the implicit move constructor) not viable}}
+// cxx11_2b-note@-1 {{candidate constructor (the implicit copy constructor) not viable}}
+// cxx98-note@-2 2{{candidate constructor (the implicit copy constructor) not viable}}
+// cxx11_2b-note@-3 {{candidate constructor (the implicit move constructor) not viable}}
struct CopyOnly {
- CopyOnly(CopyOnly&&) = delete; // cxx20_2b-note {{has been explicitly marked deleted here}}
+ CopyOnly(CopyOnly &&) = delete; // cxx11_2b-note {{has been explicitly marked deleted here}}
CopyOnly(CopyOnly&);
- operator Target() && = delete; // cxx20_2b-note {{has been explicitly marked deleted here}}
+ operator Target() && = delete; // cxx11_2b-note {{has been explicitly marked deleted here}}
operator Target() &;
};
struct MoveOnly {
- MoveOnly(MoveOnly&&); // expected-note {{copy constructor is implicitly deleted because}}
- // cxx11_17-note@-1 {{copy constructor is implicitly deleted because}}
- operator Target() &&; // expected-note {{candidate function not viable}}
- // cxx11_17-note@-1 {{candidate function not viable}}
+ MoveOnly(MoveOnly &&); // cxx11_2b-note {{copy constructor is implicitly deleted because}}
+ operator Target() &&; // expected-note {{candidate function not viable}} cxx98-note {{candidate function not viable}}
};
extern CopyOnly copyonly;
@@ -333,17 +328,17 @@
CopyOnly t2() {
CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
- return r; // cxx20_2b-error {{call to deleted constructor}}
+ return r; // cxx11_2b-error {{call to deleted constructor}}
}
MoveOnly t3() {
MoveOnly& r = moveonly;
- return r; // expected-error {{call to implicitly-deleted copy constructor}}
+ return r; // cxx11_2b-error {{call to implicitly-deleted copy constructor}}
}
MoveOnly t4() {
MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
- return r; // cxx11_17-error {{call to implicitly-deleted copy constructor}}
+ return r;
}
Target t5() {
@@ -353,7 +348,7 @@
Target t6() {
CopyOnly&& r = static_cast<CopyOnly&&>(copyonly);
- return r; // cxx20_2b-error {{invokes a deleted function}}
+ return r; // cxx11_2b-error {{invokes a deleted function}}
}
Target t7() {
@@ -363,7 +358,7 @@
Target t8() {
MoveOnly&& r = static_cast<MoveOnly&&>(moveonly);
- return r; // cxx11_17-error {{no viable conversion}}
+ return r; // cxx98-error {{no viable conversion}}
}
} // namespace test_lvalue_ref_is_not_moved_from
@@ -376,8 +371,7 @@
struct Target {
Target(CopyOnly (&)());
Target(CopyOnly (&&)()) = delete;
- Target(MoveOnly (&)()) = delete; // expected-note {{has been explicitly marked deleted here}}
- // expected-note@-1 {{has been explicitly marked deleted here}}
+ Target(MoveOnly (&)()) = delete; // expected-note 2{{has been explicitly marked deleted here}}
Target(MoveOnly (&&)());
};
@@ -406,6 +400,49 @@
} // namespace test_rvalue_ref_to_nonobject
+namespace test_constandnonconstcopy {
+struct ConstCopyOnly {
+ ConstCopyOnly();
+ ConstCopyOnly(ConstCopyOnly &) = delete; // cxx98-note {{marked deleted here}}
+ ConstCopyOnly(const ConstCopyOnly &);
+};
+ConstCopyOnly t1() {
+ ConstCopyOnly x;
+ return x; // cxx98-error {{call to deleted constructor}}
+}
+
+struct NonConstCopyOnly {
+ NonConstCopyOnly();
+ NonConstCopyOnly(NonConstCopyOnly &);
+ NonConstCopyOnly(const NonConstCopyOnly &) = delete; // cxx11_2b-note {{marked deleted here}}
+};
+NonConstCopyOnly t2() {
+ NonConstCopyOnly x;
+ return x; // cxx11_2b-error {{call to deleted constructor}}
+}
+
+} // namespace test_constandnonconstcopy
+
+namespace test_conversion {
+
+struct B;
+struct A {
+ A(B &) = delete; // cxx98-note {{has been explicitly deleted}}
+};
+struct B {
+ operator A(); // cxx98-note {{candidate function}}
+};
+A test1(B x) { return x; } // cxx98-error-re {{conversion {{.*}} is ambiguous}}
+
+struct C {};
+struct D {
+ operator C() &;
+ operator C() const & = delete; // cxx11_2b-note {{marked deleted here}}
+};
+C test2(D x) { return x; } // cxx11_2b-error {{invokes a deleted function}}
+
+} // namespace test_conversion
+
namespace test_simpler_implicit_move {
struct CopyOnly {
@@ -421,7 +458,7 @@
MoveOnly &&rref();
MoveOnly &&test1(MoveOnly &&w) {
- return w; // cxx11_20-error {{cannot bind to lvalue of type}}
+ return w; // cxx98_20-error {{cannot bind to lvalue of type}}
}
CopyOnly test2(bool b) {
@@ -434,13 +471,13 @@
}
}
-template <class T> T &&test3(T &&x) { return x; } // cxx11_20-error {{cannot bind to lvalue of type}}
+template <class T> T &&test3(T &&x) { return x; } // cxx98_20-error {{cannot bind to lvalue of type}}
template MoveOnly& test3<MoveOnly&>(MoveOnly&);
-template MoveOnly &&test3<MoveOnly>(MoveOnly &&); // cxx11_20-note {{in instantiation of function template specialization}}
+template MoveOnly &&test3<MoveOnly>(MoveOnly &&); // cxx98_20-note {{in instantiation of function template specialization}}
MoveOnly &&test4() {
MoveOnly &&x = rref();
- return x; // cxx11_20-error {{cannot bind to lvalue of type}}
+ return x; // cxx98_20-error {{cannot bind to lvalue of type}}
}
void test5() try {
Index: clang/lib/Sema/SemaStmt.cpp
===================================================================
--- clang/lib/Sema/SemaStmt.cpp
+++ clang/lib/Sema/SemaStmt.cpp
@@ -3332,7 +3332,7 @@
const auto *VD = dyn_cast<VarDecl>(DR->getDecl());
if (!VD)
return NamedReturnInfo();
- NamedReturnInfo Res = getNamedReturnInfo(VD, /*ForceCXX20=*/ForceCXX2b);
+ NamedReturnInfo Res = getNamedReturnInfo(VD);
if (Res.Candidate && !E->isXValue() &&
(ForceCXX2b || getLangOpts().CPlusPlus2b)) {
E = ImplicitCastExpr::Create(Context, VD->getType().getNonReferenceType(),
@@ -3342,46 +3342,28 @@
return Res;
}
-/// Updates the status in the given NamedReturnInfo object to disallow
-/// copy elision, and optionally also implicit move.
-///
-/// \param Info The NamedReturnInfo object to update.
-///
-/// \param CanMove If true, disallow only copy elision.
-/// If false, also disallow implcit move.
-static void disallowNRVO(Sema::NamedReturnInfo &Info, bool CanMove) {
- Info.S = std::min(Info.S, CanMove ? Sema::NamedReturnInfo::MoveEligible
- : Sema::NamedReturnInfo::None);
-}
-
/// Determine whether the given NRVO candidate variable is move-eligible or
/// copy-elidable, without considering function return type.
///
/// \param VD The NRVO candidate variable.
///
-/// \param ForceCXX20 Overrides detection of current language mode
-/// and uses the rules for C++20.
-///
/// \returns An aggregate which contains the Candidate and isMoveEligible
/// and isCopyElidable methods. If Candidate is non-null, it means
/// isMoveEligible() would be true under the most permissive language standard.
-Sema::NamedReturnInfo Sema::getNamedReturnInfo(const VarDecl *VD,
- bool ForceCXX20) {
- bool hasCXX11 = getLangOpts().CPlusPlus11 || ForceCXX20;
- bool hasCXX20 = getLangOpts().CPlusPlus20 || ForceCXX20;
+Sema::NamedReturnInfo Sema::getNamedReturnInfo(const VarDecl *VD) {
NamedReturnInfo Info{VD, NamedReturnInfo::MoveEligibleAndCopyElidable};
// C++20 [class.copy.elision]p3:
// - in a return statement in a function with ...
// (other than a function ... parameter)
if (VD->getKind() == Decl::ParmVar)
- disallowNRVO(Info, hasCXX11);
+ Info.S = NamedReturnInfo::MoveEligible;
else if (VD->getKind() != Decl::Var)
return NamedReturnInfo();
// (other than ... a catch-clause parameter)
if (VD->isExceptionVariable())
- disallowNRVO(Info, hasCXX20);
+ Info.S = NamedReturnInfo::MoveEligible;
// ...automatic...
if (!VD->hasLocalStorage())
@@ -3406,7 +3388,7 @@
if (VDReferencedType.isVolatileQualified() ||
!VDReferencedType->isObjectType())
return NamedReturnInfo();
- disallowNRVO(Info, hasCXX20);
+ Info.S = NamedReturnInfo::MoveEligible;
} else {
return NamedReturnInfo();
}
@@ -3415,7 +3397,7 @@
// alignment cannot use NRVO.
if (!VDType->isDependentType() && VD->hasAttr<AlignedAttr>() &&
Context.getDeclAlign(VD) > Context.getTypeAlignInChars(VDType))
- disallowNRVO(Info, hasCXX11);
+ Info.S = NamedReturnInfo::MoveEligible;
return Info;
}
@@ -3459,110 +3441,11 @@
// When considering moving this expression out, allow dissimilar types.
if (!VDType->isDependentType() &&
!Context.hasSameUnqualifiedType(ReturnType, VDType))
- disallowNRVO(Info, getLangOpts().CPlusPlus11);
+ Info.S = NamedReturnInfo::MoveEligible;
}
return Info.isCopyElidable() ? Info.Candidate : nullptr;
}
-/// Try to perform the initialization of a potentially-movable value,
-/// which is the operand to a return or throw statement.
-///
-/// This routine implements C++20 [class.copy.elision]p3, which attempts to
-/// treat returned lvalues as rvalues in certain cases (to prefer move
-/// construction), then falls back to treating them as lvalues if that failed.
-///
-/// \param ConvertingConstructorsOnly If true, follow [class.copy.elision]p3 and
-/// reject resolutions that find non-constructors, such as derived-to-base
-/// conversions or `operator T()&&` member functions. If false, do consider such
-/// conversion sequences.
-///
-/// \param Res We will fill this in if move-initialization was possible.
-/// If move-initialization is not possible, such that we must fall back to
-/// treating the operand as an lvalue, we will leave Res in its original
-/// invalid state.
-///
-/// \returns Whether we need to do the second overload resolution. If the first
-/// overload resolution fails, or if the first overload resolution succeeds but
-/// the selected constructor/operator doesn't match the additional criteria, we
-/// need to do the second overload resolution.
-static bool TryMoveInitialization(Sema &S, const InitializedEntity &Entity,
- const VarDecl *NRVOCandidate, Expr *&Value,
- bool ConvertingConstructorsOnly,
- bool IsDiagnosticsCheck, ExprResult &Res) {
- ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(),
- CK_NoOp, Value, VK_XValue, FPOptionsOverride());
-
- Expr *InitExpr = &AsRvalue;
-
- InitializationKind Kind = InitializationKind::CreateCopy(
- Value->getBeginLoc(), Value->getBeginLoc());
-
- InitializationSequence Seq(S, Entity, Kind, InitExpr);
-
- bool NeedSecondOverloadResolution = true;
- if (!Seq &&
- (IsDiagnosticsCheck || Seq.getFailedOverloadResult() != OR_Deleted)) {
- return NeedSecondOverloadResolution;
- }
-
- for (const InitializationSequence::Step &Step : Seq.steps()) {
- if (Step.Kind != InitializationSequence::SK_ConstructorInitialization &&
- Step.Kind != InitializationSequence::SK_UserConversion)
- continue;
-
- FunctionDecl *FD = Step.Function.Function;
- if (ConvertingConstructorsOnly) {
- if (isa<CXXConstructorDecl>(FD)) {
- // C++11 [class.copy]p32:
- // C++14 [class.copy]p32:
- // C++17 [class.copy.elision]p3:
- // [...] if the type of the first parameter of the selected constructor
- // is not an rvalue reference to the object's type (possibly
- // cv-qualified), overload resolution is performed again, considering
- // the object as an lvalue.
- const RValueReferenceType *RRefType =
- FD->getParamDecl(0)->getType()->getAs<RValueReferenceType>();
- if (!RRefType)
- break;
- if (!S.Context.hasSameUnqualifiedType(RRefType->getPointeeType(),
- NRVOCandidate->getType()))
- break;
- } else {
- continue;
- }
- } else {
- if (isa<CXXConstructorDecl>(FD)) {
- // Check that overload resolution selected a constructor taking an
- // rvalue reference. If it selected an lvalue reference, then we
- // didn't need to cast this thing to an rvalue in the first place.
- if (IsDiagnosticsCheck &&
- !isa<RValueReferenceType>(FD->getParamDecl(0)->getType()))
- break;
- } else if (isa<CXXMethodDecl>(FD)) {
- // Check that overload resolution selected a conversion operator
- // taking an rvalue reference.
- if (cast<CXXMethodDecl>(FD)->getRefQualifier() != RQ_RValue)
- break;
- } else {
- continue;
- }
- }
-
- NeedSecondOverloadResolution = false;
- // Promote "AsRvalue" to the heap, since we now need this
- // expression node to persist.
- Value =
- ImplicitCastExpr::Create(S.Context, Value->getType(), CK_NoOp, Value,
- nullptr, VK_XValue, FPOptionsOverride());
-
- // Complete type-checking the initialization of the return type
- // using the constructor we found.
- Res = Seq.Perform(S, Entity, Kind, Value);
- }
-
- return NeedSecondOverloadResolution;
-}
-
/// Perform the initialization of a potentially-movable value, which
/// is the result of return value.
///
@@ -3573,42 +3456,26 @@
Sema::PerformMoveOrCopyInitialization(const InitializedEntity &Entity,
const NamedReturnInfo &NRInfo,
Expr *Value) {
-
- if (NRInfo.Candidate && !getLangOpts().CPlusPlus2b) {
- if (NRInfo.isMoveEligible()) {
- ExprResult Res;
- if (!TryMoveInitialization(*this, Entity, NRInfo.Candidate, Value,
- !getLangOpts().CPlusPlus20, false, Res))
- return Res;
- }
- if (!getDiagnostics().isIgnored(diag::warn_return_std_move,
- Value->getExprLoc())) {
- QualType QT = NRInfo.Candidate->getType();
- if (QT.getNonReferenceType().getUnqualifiedType().isTriviallyCopyableType(
- Context)) {
- // Adding 'std::move' around a trivially copyable variable is probably
- // pointless. Don't suggest it.
- } else {
- ExprResult FakeRes = ExprError();
- Expr *FakeValue = Value;
- TryMoveInitialization(*this, Entity, NRInfo.Candidate, FakeValue, false,
- true, FakeRes);
- if (!FakeRes.isInvalid()) {
- bool IsThrow = (Entity.getKind() == InitializedEntity::EK_Exception);
- SmallString<32> Str;
- Str += "std::move(";
- Str += NRInfo.Candidate->getDeclName().getAsString();
- Str += ")";
- Diag(Value->getExprLoc(), diag::warn_return_std_move)
- << Value->getSourceRange() << NRInfo.Candidate->getDeclName()
- << IsThrow;
- Diag(Value->getExprLoc(), diag::note_add_std_move)
- << FixItHint::CreateReplacement(Value->getSourceRange(), Str);
- }
- }
+ if (getLangOpts().CPlusPlus11 && !getLangOpts().CPlusPlus2b &&
+ NRInfo.isMoveEligible()) {
+ ImplicitCastExpr AsRvalue(ImplicitCastExpr::OnStack, Value->getType(),
+ CK_NoOp, Value, VK_XValue, FPOptionsOverride());
+ Expr *InitExpr = &AsRvalue;
+ auto Kind = InitializationKind::CreateCopy(Value->getBeginLoc(),
+ Value->getBeginLoc());
+ InitializationSequence Seq(*this, Entity, Kind, InitExpr);
+ auto Res = Seq.getFailedOverloadResult();
+ if (Res == OR_Success || Res == OR_Deleted) {
+ // Promote "AsRvalue" to the heap, since we now need this
+ // expression node to persist.
+ Value =
+ ImplicitCastExpr::Create(Context, Value->getType(), CK_NoOp, Value,
+ nullptr, VK_XValue, FPOptionsOverride());
+ // Complete type-checking the initialization of the return type
+ // using the constructor we found.
+ return Seq.Perform(*this, Entity, Kind, Value);
}
}
-
// Either we didn't meet the criteria for treating an lvalue as an rvalue,
// above, or overload resolution failed. Either way, we need to try
// (again) now with the return value expression as written.
Index: clang/include/clang/Sema/Sema.h
===================================================================
--- clang/include/clang/Sema/Sema.h
+++ clang/include/clang/Sema/Sema.h
@@ -4782,8 +4782,7 @@
bool isCopyElidable() const { return S == MoveEligibleAndCopyElidable; }
};
NamedReturnInfo getNamedReturnInfo(Expr *&E, bool ForceCXX2b = false);
- NamedReturnInfo getNamedReturnInfo(const VarDecl *VD,
- bool ForceCXX20 = false);
+ NamedReturnInfo getNamedReturnInfo(const VarDecl *VD);
const VarDecl *getCopyElisionCandidate(NamedReturnInfo &Info,
QualType ReturnType);
Index: clang/include/clang/Basic/DiagnosticSemaKinds.td
===================================================================
--- clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -6485,12 +6485,6 @@
InGroup<PessimizingMove>, DefaultIgnore;
def note_remove_move : Note<"remove std::move call here">;
-def warn_return_std_move : Warning<
- "local variable %0 will be copied despite being %select{returned|thrown}1 by name">,
- InGroup<ReturnStdMove>, DefaultIgnore;
-def note_add_std_move : Note<
- "call 'std::move' explicitly to avoid copying">;
-
def warn_string_plus_int : Warning<
"adding %0 to a string does not append to the string">,
InGroup<StringPlusInt>;
_______________________________________________
cfe-commits mailing list
cfe-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
