[RTTI] Assert virtual dtor for dynamic cast

src/common/snippets/include/snippets/kernel_executor_table.hpp

@@ -79,6 +79,7 @@ class KernelExecutor : public KernelExecutorBase {
     void update_by_config(const GenericConfig& new_config) override final { // NOLINT
         if (m_config.hash() == new_config.hash())
             return;
+        static_assert(std::has_virtual_destructor_v<Conf>);
         const auto& new_ptr = dynamic_cast<const Conf*>(&new_config);
         OPENVINO_ASSERT(new_config.is_completed() && new_ptr, "Failed to update kernel config in get_config");
         m_config = *new_ptr;

src/common/snippets/include/snippets/op/memory_access.hpp

@@ -79,6 +79,7 @@ class MemoryAccess {
     explicit MemoryAccess(const std::set<size_t>& input_ports, const std::set<size_t>& output_ports);
     explicit MemoryAccess(const PortMap& input_ports, const PortMap& output_ports);
     MemoryAccess() = default;
+    virtual ~MemoryAccess() = default;
 
     // This method can be called only in ctors
     void ctor_initialize(const std::set<size_t>& input_ports, const std::set<size_t>& output_ports);

src/common/transformations/src/transformations/common_optimizations/nop_elimination.cpp

@@ -704,6 +704,7 @@ shared_ptr<T> check_all_inputs(const shared_ptr<ov::op::v0::Concat>& concat) {
     const auto concat_in_values = concat->input_values();
     size_t idx = 0;
     for (const auto& in_to_concat : concat_in_values) {
+        static_assert(std::has_virtual_destructor_v<T>);
         const auto& cast_to_split = dynamic_pointer_cast<T>(in_to_concat.get_node_shared_ptr());
         // There is a special case with (GRU/RNN/LSTM)Sequence ops:
         //

src/inference/dev_api/openvino/runtime/so_ptr.hpp

@@ -64,6 +64,7 @@ struct SoPtr {
     template <typename U>
     SoPtr(const SoPtr<U>& that) : _ptr{std::dynamic_pointer_cast<T>(that._ptr)},
                                   _so{that._so} {
+        static_assert(std::has_virtual_destructor_v<T>);
         OPENVINO_ASSERT(_ptr != nullptr);
     }
 

src/plugins/intel_cpu/src/emitters/snippets/repacked_input.hpp

@@ -25,6 +25,7 @@ struct RepackedInput {
     template <class T = RepackedInputKernel,
               typename std::enable_if<std::is_base_of<RepackedInputKernel, T>::value, bool>::type = true>
     std::shared_ptr<const T> kernel() const {
+        static_assert(std::has_virtual_destructor_v<T>);
         const auto ker = std::dynamic_pointer_cast<const T>(m_kernel);
         OPENVINO_ASSERT(ker, "Kernel is empty!");
         return ker;

src/plugins/intel_cpu/src/memory_desc/blocked_memory_desc.h

@@ -76,7 +76,7 @@ class BlockedMemoryDesc : public virtual MemoryDesc {
     virtual bool isCompatible(const BlockedMemoryDesc& rhs, CmpMask cmpMask) const = 0;
     using MemoryDesc::isCompatible;
 
-    ~BlockedMemoryDesc() override = default;
+    virtual ~BlockedMemoryDesc() override = default;
 
     std::string serializeFormat() const override;
 

src/plugins/intel_cpu/src/memory_desc/cpu_memory_desc.h

@@ -139,6 +139,7 @@ class MemoryDesc {
               typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
               typename std::enable_if<std::is_base_of<MemoryDesc, T>::value, int>::type = 0>
     T* as() {
+        static_assert(std::has_virtual_destructor_v<T>);
         T* casted = dynamic_cast<T*>(this);
         if (!casted)
             OPENVINO_THROW("Cannot dynamically cast MemoryDesc");

src/plugins/intel_cpu/src/node.h

@@ -120,6 +120,7 @@ class NodeDesc {
               typename std::enable_if<!std::is_pointer<T>::value && !std::is_reference<T>::value, int>::type = 0,
               typename std::enable_if<std::is_base_of<ExecutorFactoryLegacy, T>::value, int>::type = 0>
     std::shared_ptr<T> getExecutorFactoryAs() {
+        static_assert(std::has_virtual_destructor_v<T>);
         auto casted = std::dynamic_pointer_cast<T>(executorFactory);
         if (!casted)
             OPENVINO_THROW("Cannot dynamically cast ExecutorFactory");

src/plugins/intel_cpu/src/transformations/cpu_opset/arm/pass/convert_group_conv1d.cpp

@@ -13,6 +13,7 @@
 template <class Conv>
 ov::matcher_pass_callback ov::intel_cpu::ConvertConv1DBase::convert_conv1d_to_conv2d() {
     return [&](ov::pass::pattern::Matcher& m) {
+        static_assert(std::has_virtual_destructor_v<Conv>);
         auto conv = std::dynamic_pointer_cast<Conv>(m.get_match_root());
         if (!conv) {
             return false;

src/plugins/intel_cpu/src/transformations/cpu_opset/arm/pass/convert_reduce_multi_axis.cpp

@@ -10,6 +10,7 @@
 template <class T>
 ov::matcher_pass_callback ov::intel_cpu::ConvertReduceMultiAxisBase::convert_reduce() {
     return [&](ov::pass::pattern::Matcher& m) {
+        static_assert(std::has_virtual_destructor_v<T>);
         auto reduce = std::dynamic_pointer_cast<T>(m.get_match_root());
         if (!reduce) {
             return false;

src/plugins/intel_cpu/src/transformations/cpu_opset/arm/pass/convert_reduce_no_keep_dims.cpp

@@ -9,6 +9,7 @@
 template <class T>
 ov::matcher_pass_callback ov::intel_cpu::ConvertReduceNoKeepDimsBase::convert_reduce() {
     return [&](ov::pass::pattern::Matcher& m) {
+        static_assert(std::has_virtual_destructor_v<T>);
         auto reduce = std::dynamic_pointer_cast<T>(m.get_match_root());
         if (!reduce || reduce->get_keep_dims()) {
             return false;

src/plugins/intel_gpu/include/intel_gpu/graph/fused_primitive_desc.hpp

@@ -35,6 +35,7 @@ struct fused_primitive_desc {
 
     template<typename T>
     std::shared_ptr<T> get_typed_fuse_params() const {
+        static_assert(std::has_virtual_destructor_v<T>);
         auto p = std::dynamic_pointer_cast<T>(f_param);
         if (!p)
             throw std::runtime_error("Invalid dynamic cast of fused parameters!");

src/plugins/intel_gpu/include/intel_gpu/plugin/program_builder.hpp

@@ -37,16 +37,17 @@ enum class reduce_mode : uint16_t;
 enum class eltwise_mode : int32_t;
 }  // namespace cldnn
 
-#define REGISTER_FACTORY_IMPL(op_version, op_name)                                                  \
-void __register ## _ ## op_name ## _ ## op_version();                                               \
-void __register ## _ ## op_name ## _ ## op_version() {                                              \
-    ProgramBuilder::RegisterFactory<ov::op::op_version::op_name>(                                   \
-    [](ProgramBuilder& p, const std::shared_ptr<ov::Node>& op) {                                    \
-        auto op_casted = std::dynamic_pointer_cast<ov::op::op_version::op_name>(op);                \
-        OPENVINO_ASSERT(op_casted, "[GPU] Invalid ov Node type passed into ", __PRETTY_FUNCTION__); \
-        Create##op_name##Op(p, op_casted);                                                          \
-       });                                                                                          \
-}
+#define REGISTER_FACTORY_IMPL(op_version, op_name)                                                          \
+    void __register##_##op_name##_##op_version();                                                           \
+    void __register##_##op_name##_##op_version() {                                                          \
+        ProgramBuilder::RegisterFactory<ov::op::op_version::op_name>(                                       \
+            [](ProgramBuilder& p, const std::shared_ptr<ov::Node>& op) {                                    \
+                static_assert(std::has_virtual_destructor_v<ov::op::op_version::op_name>);                  \
+                auto op_casted = std::dynamic_pointer_cast<ov::op::op_version::op_name>(op);                \
+                OPENVINO_ASSERT(op_casted, "[GPU] Invalid ov Node type passed into ", __PRETTY_FUNCTION__); \
+                Create##op_name##Op(p, op_casted);                                                          \
+            });                                                                                             \
+    }
 
 namespace ov {
 namespace intel_gpu {

src/plugins/intel_gpu/src/graph/impls/ocl/primitive_base.hpp

@@ -173,6 +173,7 @@ struct typed_primitive_impl_ocl : public typed_primitive_impl<PType> {
     template<typename ImplType, typename KernelParamsType>
     static std::unique_ptr<primitive_impl> make_deep_copy(const ImplType& impl_ocl) {
         auto prim_impl = make_unique<ImplType>(impl_ocl);
+        static_assert(std::has_virtual_destructor_v<KernelParamsType>);
         KernelParamsType* params_ptr = dynamic_cast<KernelParamsType*>((*prim_impl)._kernel_data.params.get());
         if (params_ptr != nullptr) {
             (*prim_impl)._kernel_data.params = make_unique<KernelParamsType>(*params_ptr);

src/plugins/intel_gpu/src/kernel_selector/kernel_selector_params.h

@@ -634,6 +634,7 @@ struct fused_operation_desc {
     KernelType GetType() const { return op_params->GetType(); }
     template<typename T>
     std::shared_ptr<T> GetOpParams() const {
+        static_assert(std::has_virtual_destructor_v<T>);
         auto p = std::dynamic_pointer_cast<T>(op_params);
         if (!p)
             throw std::runtime_error("Invalid dynamic cast of fused operation parameters");

src/plugins/intel_gpu/src/plugin/transformations_pipeline.cpp

@@ -174,6 +174,7 @@
 namespace {
 template<typename T>
 static bool disable_reduce_decomposition(const std::shared_ptr<const ov::Node> node) {
+    static_assert(std::has_virtual_destructor_v<T>);
     if (auto op = std::dynamic_pointer_cast<const T>(node)) {
         if (op->input(0).get_partial_shape()[0].is_static()) {
             bool fp16_batch_not_1 = op->get_element_type() == ov::element::f16 && op->input(0).get_partial_shape()[0] != 1;

src/plugins/intel_gpu/tests/unit/module_tests/impls_registry_test.cpp

@@ -101,6 +101,7 @@ void check_impl() {
     size_t actual_impls_count = 0;
     for (size_t i = 0; i < all_impls.size(); i++) {
         ASSERT_NE(all_impls[i], nullptr) << " Implementation " << i << " of " << PType().type_string();
+        static_assert(std::has_virtual_destructor_v<PType>);
         if (std::dynamic_pointer_cast<ImplementationManagerLegacy<PType>>(all_impls[i]) != nullptr)
             actual_impls_count++;
     }

src/plugins/template/src/remote_tensor.hpp

@@ -20,6 +20,7 @@ class VectorImpl : public ov::IRemoteTensor {
 
     template <class T>
     operator std::vector<T>&() const {
+        static_assert(std::has_virtual_destructor_v<T>);
         auto impl = std::dynamic_pointer_cast<VectorTensorImpl<T>>(m_tensor);
         OPENVINO_ASSERT(impl, "Cannot get vector. Type is incorrect!");
         return impl->get();