head 1.1; branch 1.1.1; access; symbols netbsd-11-0-RC5:1.1.1.2 netbsd-11-0-RC4:1.1.1.2 netbsd-11-0-RC3:1.1.1.2 netbsd-11-0-RC2:1.1.1.2 netbsd-11-0-RC1:1.1.1.2 perseant-exfatfs-base-20250801:1.1.1.2 netbsd-11:1.1.1.2.0.10 netbsd-11-base:1.1.1.2 netbsd-10-1-RELEASE:1.1.1.2 perseant-exfatfs-base-20240630:1.1.1.2 perseant-exfatfs:1.1.1.2.0.8 perseant-exfatfs-base:1.1.1.2 netbsd-9-4-RELEASE:1.1.1.1 netbsd-10-0-RELEASE:1.1.1.2 netbsd-10-0-RC6:1.1.1.2 netbsd-10-0-RC5:1.1.1.2 netbsd-10-0-RC4:1.1.1.2 netbsd-10-0-RC3:1.1.1.2 netbsd-10-0-RC2:1.1.1.2 netbsd-10-0-RC1:1.1.1.2 netbsd-10:1.1.1.2.0.6 netbsd-10-base:1.1.1.2 netbsd-9-3-RELEASE:1.1.1.1 cjep_sun2x:1.1.1.2.0.4 cjep_sun2x-base:1.1.1.2 cjep_staticlib_x-base1:1.1.1.2 netbsd-9-2-RELEASE:1.1.1.1 cjep_staticlib_x:1.1.1.2.0.2 cjep_staticlib_x-base:1.1.1.2 netbsd-9-1-RELEASE:1.1.1.1 phil-wifi-20200421:1.1.1.2 phil-wifi-20200411:1.1.1.2 phil-wifi-20200406:1.1.1.2 netbsd-9-0-RELEASE:1.1.1.1 netbsd-9-0-RC2:1.1.1.1 netbsd-9-0-RC1:1.1.1.1 netbsd-9:1.1.1.1.0.6 netbsd-9-base:1.1.1.1 phil-wifi:1.1.1.1.0.4 phil-wifi-20190609:1.1.1.1 pgoyette-compat-merge-20190127:1.1.1.1.2.2 pgoyette-compat-20190127:1.1.1.1 pgoyette-compat-20190118:1.1.1.1 pgoyette-compat-1226:1.1.1.1 pgoyette-compat-1126:1.1.1.1 pgoyette-compat-1020:1.1.1.1 pgoyette-compat-0930:1.1.1.1 pgoyette-compat-0906:1.1.1.1 pgoyette-compat:1.1.1.1.0.2 pgoyette-compat-0728:1.1.1.1 clang-337282:1.1.1.1 LLVM:1.1.1; locks; strict; comment @// @; 1.1 date 2018.07.17.18.31.35; author joerg; state Exp; branches 1.1.1.1; next ; commitid wDzL46ALjrCZgwKA; 1.1.1.1 date 2018.07.17.18.31.35; author joerg; state Exp; branches 1.1.1.1.2.1 1.1.1.1.4.1; next 1.1.1.2; commitid wDzL46ALjrCZgwKA; 1.1.1.2 date 2019.11.13.22.22.56; author joerg; state dead; branches; next ; commitid QD8YATxuNG34YJKB; 1.1.1.1.2.1 date 2018.07.17.18.31.35; author pgoyette; state dead; branches; next 1.1.1.1.2.2; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.1.2.2 date 2018.07.28.04.34.12; author pgoyette; state Exp; branches; next ; commitid 1UP1xAIUxv1ZgRLA; 1.1.1.1.4.1 date 2018.07.17.18.31.35; author christos; state dead; branches; next 1.1.1.1.4.2; commitid jtc8rnCzWiEEHGqB; 1.1.1.1.4.2 date 2019.06.10.21.46.36; author christos; state Exp; branches; next 1.1.1.1.4.3; commitid jtc8rnCzWiEEHGqB; 1.1.1.1.4.3 date 2020.04.13.07.50.23; author martin; state dead; branches; next ; commitid X01YhRUPVUDaec4C; desc @@ 1.1 log @Initial revision @ text @// RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DDUMMY -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV0 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV1 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV2 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV3 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV4 -verify %s #ifdef DUMMY struct S {}; #else struct S { #if defined(V0) S() = default; #elif defined(V1) S &operator=(const S &) = default; #elif defined(V2) S &operator=(S &) = default; #elif defined(V3) S &operator=(const S &); #elif defined(V4) S &operator=(S &); #else #error Define something! #endif S &operator*=(const S &); S &operator/=(const S &); S &operator%=(const S &); S &operator+=(const S &); S &operator-=(const S &); S &operator<<=(const S &); S &operator>>=(const S &); S &operator&=(const S &); S &operator|=(const S &); S &operator^=(const S &); S &operator=(const volatile S &) volatile; }; #endif struct C { S a; S b; void f() { a = a; // expected-warning {{assigning field to itself}} b = b; // expected-warning {{assigning field to itself}} a = b; this->a = a; // expected-warning {{assigning field to itself}} this->b = b; // expected-warning {{assigning field to itself}} a = this->a; // expected-warning {{assigning field to itself}} b = this->b; // expected-warning {{assigning field to itself}} this->a = this->a; // expected-warning {{assigning field to itself}} this->b = this->b; // expected-warning {{assigning field to itself}} a = b; a = this->b; this->a = b; this->a = this->b; #ifndef DUMMY a *= a; a /= a; // expected-warning {{assigning field to itself}} a %= a; // expected-warning {{assigning field to itself}} a += a; a -= a; // expected-warning {{assigning field to itself}} a <<= a; a >>= a; a &= a; // expected-warning {{assigning field to itself}} a |= a; // expected-warning {{assigning field to itself}} a ^= a; // expected-warning {{assigning field to itself}} #endif } void false_positives() { #define OP = #define LHS a #define RHS a // These shouldn't warn due to the use of the preprocessor. a OP a; LHS = a; a = RHS; LHS OP RHS; #undef OP #undef LHS #undef RHS // Ways to silence the warning. a = *&a; a = (S &)a; a = static_cast(a); } #ifndef DUMMY volatile S vol_a; void vol_test() { // Volatile stores aren't side-effect free. vol_a = vol_a; volatile S &vol_a_ref = vol_a; vol_a_ref = vol_a_ref; } #endif }; // Do not diagnose self-assigment in an unevaluated context struct SNoExcept { SNoExcept() = default; SNoExcept &operator=(const SNoExcept &) noexcept; }; struct false_positives_unevaluated_ctx_class { SNoExcept a; void false_positives_unevaluated_ctx(SNoExcept a) noexcept(noexcept(a = a)) { decltype(a = a) b = a; static_assert(noexcept(a = a), ""); static_assert(sizeof(a = a), ""); } }; template struct TemplateClass { T var; void f() { var = var; // expected-warning {{assigning field to itself}} } }; void instantiate() { { TemplateClass c; c.f(); } { TemplateClass c; c.f(); } } // It may make sense not to warn on the rest of the tests. // It may be a valid use-case to self-assign to tell the compiler that // it is ok to vectorize the store. void f0(C *s, C *t) { s->a = s->a; t->a = s->a; } void f1(C &s, C &t) { s.a = s.a; t.a = s.a; } struct T { C *s; }; void f2(T *t, T *t2) { t->s->a = t->s->a; t2->s->a = t->s->a; } void f3(T &t, T &t2) { t.s->a = t.s->a; t2.s->a = t.s->a; } @ 1.1.1.1 log @Import clang r337282 from trunk @ text @@ 1.1.1.2 log @Mark old LLVM instance as dead. @ text @@ 1.1.1.1.4.1 log @file warn-self-assign-field-overloaded.cpp was added on branch phil-wifi on 2019-06-10 21:46:36 +0000 @ text @d1 162 @ 1.1.1.1.4.2 log @Sync with HEAD @ text @a0 162 // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DDUMMY -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV0 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV1 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV2 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV3 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV4 -verify %s #ifdef DUMMY struct S {}; #else struct S { #if defined(V0) S() = default; #elif defined(V1) S &operator=(const S &) = default; #elif defined(V2) S &operator=(S &) = default; #elif defined(V3) S &operator=(const S &); #elif defined(V4) S &operator=(S &); #else #error Define something! #endif S &operator*=(const S &); S &operator/=(const S &); S &operator%=(const S &); S &operator+=(const S &); S &operator-=(const S &); S &operator<<=(const S &); S &operator>>=(const S &); S &operator&=(const S &); S &operator|=(const S &); S &operator^=(const S &); S &operator=(const volatile S &) volatile; }; #endif struct C { S a; S b; void f() { a = a; // expected-warning {{assigning field to itself}} b = b; // expected-warning {{assigning field to itself}} a = b; this->a = a; // expected-warning {{assigning field to itself}} this->b = b; // expected-warning {{assigning field to itself}} a = this->a; // expected-warning {{assigning field to itself}} b = this->b; // expected-warning {{assigning field to itself}} this->a = this->a; // expected-warning {{assigning field to itself}} this->b = this->b; // expected-warning {{assigning field to itself}} a = b; a = this->b; this->a = b; this->a = this->b; #ifndef DUMMY a *= a; a /= a; // expected-warning {{assigning field to itself}} a %= a; // expected-warning {{assigning field to itself}} a += a; a -= a; // expected-warning {{assigning field to itself}} a <<= a; a >>= a; a &= a; // expected-warning {{assigning field to itself}} a |= a; // expected-warning {{assigning field to itself}} a ^= a; // expected-warning {{assigning field to itself}} #endif } void false_positives() { #define OP = #define LHS a #define RHS a // These shouldn't warn due to the use of the preprocessor. a OP a; LHS = a; a = RHS; LHS OP RHS; #undef OP #undef LHS #undef RHS // Ways to silence the warning. a = *&a; a = (S &)a; a = static_cast(a); } #ifndef DUMMY volatile S vol_a; void vol_test() { // Volatile stores aren't side-effect free. vol_a = vol_a; volatile S &vol_a_ref = vol_a; vol_a_ref = vol_a_ref; } #endif }; // Do not diagnose self-assigment in an unevaluated context struct SNoExcept { SNoExcept() = default; SNoExcept &operator=(const SNoExcept &) noexcept; }; struct false_positives_unevaluated_ctx_class { SNoExcept a; void false_positives_unevaluated_ctx(SNoExcept a) noexcept(noexcept(a = a)) { decltype(a = a) b = a; static_assert(noexcept(a = a), ""); static_assert(sizeof(a = a), ""); } }; template struct TemplateClass { T var; void f() { var = var; // expected-warning {{assigning field to itself}} } }; void instantiate() { { TemplateClass c; c.f(); } { TemplateClass c; c.f(); } } // It may make sense not to warn on the rest of the tests. // It may be a valid use-case to self-assign to tell the compiler that // it is ok to vectorize the store. void f0(C *s, C *t) { s->a = s->a; t->a = s->a; } void f1(C &s, C &t) { s.a = s.a; t.a = s.a; } struct T { C *s; }; void f2(T *t, T *t2) { t->s->a = t->s->a; t2->s->a = t->s->a; } void f3(T &t, T &t2) { t.s->a = t.s->a; t2.s->a = t.s->a; } @ 1.1.1.1.4.3 log @Mostly merge changes from HEAD upto 20200411 @ text @@ 1.1.1.1.2.1 log @file warn-self-assign-field-overloaded.cpp was added on branch pgoyette-compat on 2018-07-28 04:34:12 +0000 @ text @d1 162 @ 1.1.1.1.2.2 log @Sync with HEAD @ text @a0 162 // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DDUMMY -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV0 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV1 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV2 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV3 -verify %s // RUN: %clang_cc1 -fsyntax-only -Wself-assign-field -DV4 -verify %s #ifdef DUMMY struct S {}; #else struct S { #if defined(V0) S() = default; #elif defined(V1) S &operator=(const S &) = default; #elif defined(V2) S &operator=(S &) = default; #elif defined(V3) S &operator=(const S &); #elif defined(V4) S &operator=(S &); #else #error Define something! #endif S &operator*=(const S &); S &operator/=(const S &); S &operator%=(const S &); S &operator+=(const S &); S &operator-=(const S &); S &operator<<=(const S &); S &operator>>=(const S &); S &operator&=(const S &); S &operator|=(const S &); S &operator^=(const S &); S &operator=(const volatile S &) volatile; }; #endif struct C { S a; S b; void f() { a = a; // expected-warning {{assigning field to itself}} b = b; // expected-warning {{assigning field to itself}} a = b; this->a = a; // expected-warning {{assigning field to itself}} this->b = b; // expected-warning {{assigning field to itself}} a = this->a; // expected-warning {{assigning field to itself}} b = this->b; // expected-warning {{assigning field to itself}} this->a = this->a; // expected-warning {{assigning field to itself}} this->b = this->b; // expected-warning {{assigning field to itself}} a = b; a = this->b; this->a = b; this->a = this->b; #ifndef DUMMY a *= a; a /= a; // expected-warning {{assigning field to itself}} a %= a; // expected-warning {{assigning field to itself}} a += a; a -= a; // expected-warning {{assigning field to itself}} a <<= a; a >>= a; a &= a; // expected-warning {{assigning field to itself}} a |= a; // expected-warning {{assigning field to itself}} a ^= a; // expected-warning {{assigning field to itself}} #endif } void false_positives() { #define OP = #define LHS a #define RHS a // These shouldn't warn due to the use of the preprocessor. a OP a; LHS = a; a = RHS; LHS OP RHS; #undef OP #undef LHS #undef RHS // Ways to silence the warning. a = *&a; a = (S &)a; a = static_cast(a); } #ifndef DUMMY volatile S vol_a; void vol_test() { // Volatile stores aren't side-effect free. vol_a = vol_a; volatile S &vol_a_ref = vol_a; vol_a_ref = vol_a_ref; } #endif }; // Do not diagnose self-assigment in an unevaluated context struct SNoExcept { SNoExcept() = default; SNoExcept &operator=(const SNoExcept &) noexcept; }; struct false_positives_unevaluated_ctx_class { SNoExcept a; void false_positives_unevaluated_ctx(SNoExcept a) noexcept(noexcept(a = a)) { decltype(a = a) b = a; static_assert(noexcept(a = a), ""); static_assert(sizeof(a = a), ""); } }; template struct TemplateClass { T var; void f() { var = var; // expected-warning {{assigning field to itself}} } }; void instantiate() { { TemplateClass c; c.f(); } { TemplateClass c; c.f(); } } // It may make sense not to warn on the rest of the tests. // It may be a valid use-case to self-assign to tell the compiler that // it is ok to vectorize the store. void f0(C *s, C *t) { s->a = s->a; t->a = s->a; } void f1(C &s, C &t) { s.a = s.a; t.a = s.a; } struct T { C *s; }; void f2(T *t, T *t2) { t->s->a = t->s->a; t2->s->a = t->s->a; } void f3(T &t, T &t2) { t.s->a = t.s->a; t2.s->a = t.s->a; } @