https://github.com/mugiwaraluffy56 updated https://github.com/llvm/llvm-project/pull/178654
>From bc8ac887ae99462c67341b06dbed98c4517b1384 Mon Sep 17 00:00:00 2001 From: mugiwaraluffy56 <[email protected]> Date: Thu, 29 Jan 2026 19:09:20 +0530 Subject: [PATCH] [clang][analyzer] Don't warn about virtual calls in final class destructors When a virtual method is called during construction or destruction of an object whose type is a final class, virtual dispatch is safe because there can be no derived classes that could override the method. This patch checks: 1. If the object's type is effectively final 2. If the called method's class is effectively final Added comprehensive tests including nested/interprocedural call scenarios. Fixes #178643. Assisted-by: claude --- .../Checkers/VirtualCallChecker.cpp | 13 ++++ clang/test/Analysis/virtualcall.cpp | 75 ++++++++++++++++++- 2 files changed, 87 insertions(+), 1 deletion(-) diff --git a/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp index 6c27f58d308aa..2856fb928d77e 100644 --- a/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/VirtualCallChecker.cpp @@ -123,6 +123,19 @@ void VirtualCallChecker::checkPreCall(const CallEvent &Call, if (!ObState) return; + // If the object's dynamic type is a final class, virtual dispatch is safe + // because there can be no derived classes. We check both: + // 1. The object's type (for calls on objects of final class type) + // 2. The called method's class (for methods declared in final classes) + if (const auto *TR = dyn_cast<TypedValueRegion>(Reg)) { + QualType ObjType = TR->getValueType(); + if (const auto *RD = ObjType->getAsCXXRecordDecl()) + if (RD->isEffectivelyFinal()) + return; + } + if (MD->getParent()->isEffectivelyFinal()) + return; + bool IsPure = MD->isPureVirtual(); // At this point we're sure that we're calling a virtual method diff --git a/clang/test/Analysis/virtualcall.cpp b/clang/test/Analysis/virtualcall.cpp index 82285b6d12844..0a7f9fd1df971 100644 --- a/clang/test/Analysis/virtualcall.cpp +++ b/clang/test/Analysis/virtualcall.cpp @@ -84,6 +84,75 @@ class E final : public B { int foo() override; }; +// GH#178643: Virtual calls in destructor of a final class should not warn. +class GH178643Base { +public: + virtual void virtualMethod() {} + virtual ~GH178643Base() { + // Base class destructor should still warn even when destructing a final + // derived class, because the vtable points to the base class at this point. + virtualMethod(); // impure-warning {{Call to virtual method 'GH178643Base::virtualMethod' during destruction bypasses virtual dispatch}} + } +}; + +class GH178643Derived final : public GH178643Base { +public: + ~GH178643Derived() { + virtualMethod(); // no-warning: class is final, no derived classes exist + } +}; + +// Test constructor case for final class. +class GH178643CtorBase { +public: + virtual void virtualMethod() {} + GH178643CtorBase() { + virtualMethod(); // impure-warning {{Call to virtual method 'GH178643CtorBase::virtualMethod' during construction bypasses virtual dispatch}} + } +}; + +class GH178643CtorDerived final : public GH178643CtorBase { +public: + GH178643CtorDerived() { + virtualMethod(); // no-warning: class is final + } +}; + +// Test nested calls from destructor - destructor calls helper which makes +// virtual call. This tests interprocedural behavior. +class GH178643NestedBase { +public: + virtual void virtualMethod() {} + void helper() { + // Called from destructor via nested call - should still warn because + // this helper could be called from non-final derived classes too. + virtualMethod(); // impure-warning {{Call to virtual method 'GH178643NestedBase::virtualMethod' during destruction bypasses virtual dispatch}} + } + virtual ~GH178643NestedBase() = default; +}; + +class GH178643NestedDerived final : public GH178643NestedBase { +public: + ~GH178643NestedDerived() { + helper(); // Calls helper() which calls virtualMethod() + } +}; + +// Test: final class with method overridden - should not warn. +class GH178643OverrideBase { +public: + virtual void virtualMethod() {} + virtual ~GH178643OverrideBase() = default; +}; + +class GH178643OverrideDerived final : public GH178643OverrideBase { +public: + void virtualMethod() override {} + ~GH178643OverrideDerived() { + virtualMethod(); // no-warning: method is in final class + } +}; + class F { public: F() { @@ -175,12 +244,16 @@ int main() { G g; H h; H h1(1); - X x; + X x; X x1(1); M m; Y *y = new Y; delete y; header::Z z; + GH178643Derived gh178643; + GH178643CtorDerived gh178643ctor; + GH178643NestedDerived gh178643nested; + GH178643OverrideDerived gh178643override; } namespace PR34451 { _______________________________________________ cfe-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
