[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