[clang] [analyzer] Add cplusplus.DestroyedAsWrongType checker (PR #237801)
via cfe-commits
cfe-commits at lists.llvm.org
Wed Nov 4 11:46:00 PST 2026
================
@@ -0,0 +1,358 @@
+// RUN: %clang_analyze_cc1 -std=c++11 %s \
+// RUN: -analyzer-checker=core,cplusplus.DestroyedAsWrongType \
+// RUN: -analyzer-output=text -verify -triple x86_64-unknown-linux-gnu
+
+#include "Inputs/system-header-simulator-cxx.h"
+
+struct A {};
+
+struct B {
+ ~B();
+};
+
+void consume(void *);
+
+void replace_local() {
+ B b;
+ new (&b) A; // expected-note{{Object of type 'A' is created here by placement new}}
+} // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+
+void replace_heap() {
+ B *b = new B;
+ new (b) A; // expected-note{{Object of type 'A' is created here by placement new}}
+ delete b; // expected-warning{{Deleting an object of type 'A' through a pointer to 'B'}} expected-note{{Deleting an object of type 'A' through a pointer to 'B'}}
+}
+
+struct Base {
+ ~Base();
+};
+struct Derived : Base {};
+
+void delete_through_base_without_virtual_dtor() {
+ Base *p = new Base;
+ new (p) Derived; // expected-note{{Object of type 'Derived' is created here by placement new}}
+ delete p; // expected-warning{{Deleting an object of type 'Derived' through a pointer to 'Base'}} expected-note{{Deleting an object of type 'Derived' through a pointer to 'Base'}}
+}
+
+struct Holder { // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+ B Member;
+};
+
+void replace_member() {
+ Holder h;
+ new (&h.Member) A; // expected-note{{Object of type 'A' is created here by placement new}}
+} // expected-note{{Calling implicit destructor for 'Holder'}}
+
+void destroy_then_replace() {
+ B b;
+ b.~B();
+ new (&b) A; // expected-note{{Object of type 'A' is created here by placement new}}
+} // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+
+void explicit_destructor_on_replaced_storage() {
+ B b;
+ new (&b) A; // expected-note{{Object of type 'A' is created here by placement new}}
+ b.~B(); // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+}
+
+void restore_after_destroying_placed_object() {
+ B b;
+ b.~B();
+ new (&b) A;
+ reinterpret_cast<A *>(&b)->~A();
+ new (&b) B;
+} // no-warning
+
+void reconstruct_original_type() {
+ B b;
+ b.~B();
+ new (&b) B;
+} // no-warning
+
+void reconstruct_on_heap() {
+ B *b = new B;
+ b->~B();
+ new (b) B;
+ delete b; // no-warning
+}
+
+struct VBase {
+ virtual ~VBase();
+};
+struct VDerived : VBase {};
+
+void delete_through_base_with_virtual_dtor() {
+ VBase *p = new VBase;
+ p->~VBase();
+ new (p) VDerived;
+ delete p; // no-warning
+}
+
+void explicit_virtual_destructor_through_base() {
+ VBase *p = new VBase;
+ p->~VBase();
+ new (p) VDerived;
+ p->~VBase(); // no-warning
+}
+
+void storage_passed_to_opaque_function() {
+ B b;
+ new (&b) A; // expected-note{{Object of type 'A' is created here by placement new}}
+ consume(&b);
+} // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+
+struct WithDtor {
+ ~WithDtor();
+};
+struct DerivedFromWithDtor : WithDtor {};
+
+void raw_memory_destroyed_through_base() {
+ void *Raw = ::operator new(sizeof(DerivedFromWithDtor));
+ WithDtor *P = new (Raw) DerivedFromWithDtor;
+ P->~WithDtor();
+ ::operator delete(Raw);
+} // no-warning
+
+void raw_local_buffer() {
+ alignas(B) unsigned char Buf[sizeof(B)];
+ B *P = new (Buf) B;
+ P->~B();
+} // no-warning
+
+union OneOf {
+ B First;
+ A Second;
+ OneOf() { new (this) B; }
+ ~OneOf();
+};
+
+void union_member_created_through_union_address() {
+ OneOf U;
+ U.~OneOf();
+ new (&U) OneOf;
+} // no-warning
+
+struct Reassignable {
+ Reassignable();
+ Reassignable(const Reassignable &);
+ ~Reassignable();
+ Reassignable &operator=(const Reassignable &Other) {
+ this->~Reassignable();
+ new (this) Reassignable(Other); // expected-note{{Object of type 'Reassignable' is created here by placement new}}
+ return *this;
+ }
+};
+struct WrapsReassignable : Reassignable {};
+
+void recreate_base_subobject(const WrapsReassignable &Other) {
+ WrapsReassignable W;
+ W = Other; // expected-note{{Calling implicit copy assignment operator for 'WrapsReassignable'}} expected-note{{Calling copy assignment operator for 'Reassignable'}} expected-note{{Returning from copy assignment operator for 'Reassignable'}} expected-note{{Returning from copy assignment operator for 'WrapsReassignable'}}
+} // expected-warning{{Destructor of 'WrapsReassignable' is called on storage that holds an object of type 'Reassignable'}} expected-note{{Destructor of 'WrapsReassignable' is called on storage that holds an object of type 'Reassignable'}}
+
+struct Trivial {
+ int X;
+};
+
+void trivially_destructible_storage() {
+ Trivial t;
+ new (&t) A;
+} // no-warning
+
+struct WithPlacementNew {
+ ~WithPlacementNew();
+ static void *operator new(size_t, void *P) { return P; }
+};
+
+void restore_through_class_placement_new() {
+ WithPlacementNew W;
+ W.~WithPlacementNew();
+ ::new (&W) A;
+ new (&W) WithPlacementNew;
+} // no-warning
+
+struct WithOpaquePlacementNew {
+ ~WithOpaquePlacementNew();
+ static void *operator new(size_t, void *P);
+};
+
+void restore_through_opaque_class_placement_new() {
+ WithOpaquePlacementNew W;
+ W.~WithOpaquePlacementNew();
+ ::new (&W) A;
+ new (&W) WithOpaquePlacementNew;
+} // no-warning
+
+struct OffsetHolder {
+ int X;
+ B Member;
+};
+
+void restore_member_through_byte_offset() {
+ OffsetHolder H;
+ H.Member.~B();
+ ::new (&H.Member) A;
+ ::new (reinterpret_cast<char *>(&H) + __builtin_offsetof(OffsetHolder, Member)) B;
+} // no-warning
+
+struct PlacementTag {};
+struct WithTaggedPlacementNew {
+ ~WithTaggedPlacementNew();
+ static void *operator new(size_t, PlacementTag, void *P) { return P; }
+};
+
+void restore_through_tagged_placement_new() {
+ WithTaggedPlacementNew W;
+ W.~WithTaggedPlacementNew();
+ ::new (&W) A;
+ new (PlacementTag{}, &W) WithTaggedPlacementNew;
+} // no-warning
+
+struct PlacedWithClassNew {
+ static void *operator new(size_t, void *P) { return P; }
+};
+
+void replace_through_class_placement_new() {
+ B b;
+ new (&b) PlacedWithClassNew; // expected-note{{Object of type 'PlacedWithClassNew' is created here by placement new}}
+} // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'PlacedWithClassNew'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'PlacedWithClassNew'}}
+
+struct EscapingHolder { // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+ B Member;
+};
+
+void member_passed_to_opaque_function_with_parent() {
+ EscapingHolder H;
+ new (&H.Member) A; // expected-note{{Object of type 'A' is created here by placement new}}
+ consume(&H);
+} // expected-note{{Calling implicit destructor for 'EscapingHolder'}}
+
+struct MutatedHolder { // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+ B Member;
+ void mutate();
+};
+
+void member_of_object_with_opaque_method() {
+ MutatedHolder H;
+ new (&H.Member) A; // expected-note{{Object of type 'A' is created here by placement new}}
+ H.mutate();
+} // expected-note{{Calling implicit destructor for 'MutatedHolder'}}
+
+struct HeapHolder { // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+ B Member;
+};
+
+void heap_member_passed_to_opaque_function_with_parent() {
+ HeapHolder *H = new HeapHolder;
+ new (&H->Member) A; // expected-note{{Object of type 'A' is created here by placement new}}
+ consume(H);
+ delete H; // expected-note{{Calling implicit destructor for 'HeapHolder'}}
+}
+
+struct OpaqueDtorHolder {
+ B Member;
+ ~OpaqueDtorHolder();
+};
+
+void member_destroyed_by_opaque_destructor() {
+ OpaqueDtorHolder H;
+ new (&H.Member) A; // expected-note{{Object of type 'A' is created here by placement new}}
+} // expected-warning{{Destructor of 'B' is called on storage that holds an object of type 'A'}} expected-note{{Destructor of 'B' is called on storage that holds an object of type 'A'}}
+
+void member_restored_before_opaque_destructor() {
+ OpaqueDtorHolder H;
+ H.Member.~B();
+ new (&H.Member) A;
+ reinterpret_cast<A *>(&H.Member)->~A();
+ new (&H.Member) B;
+} // no-warning
+
+void array_element() {
----------------
mark-zilber wrote:
Added
https://github.com/llvm/llvm-project/pull/237801
More information about the cfe-commits
mailing list