[Core][GPU][Hetero] Add compile-time guard to prevent string-literal conditions in OPENVINO_ASSERT

Add guard and update hetero/gpu code paths to use OPENVINO_THROW or explicit predicate asserts

Author: aobolensk

src/common/low_precision_transformations/include/low_precision/layer_transformation.hpp

@@ -131,7 +131,7 @@ class LP_TRANSFORMATIONS_API DataPrecision {
             default:
                 OPENVINO_ASSERT(false, "unexpected precision ", precision);
         }
-        OPENVINO_ASSERT(false, "unexpected levels ", levels, " for precision ", precision);
+        OPENVINO_THROW("unexpected levels ", levels, " for precision ", precision);
     }
 
     static float getMaxValue(const element::Type precision, const size_t levels) {

src/common/transformations/tests/op_conversions/sdpa_to_paged_attention_test.cpp

@@ -80,18 +80,18 @@ namespace v13 = ov::op::v13;
 namespace {
 
 // Constants and Parameters attributes:
-auto el_type_i64 = std::pair<std::string, detail::AttrAny>({"element_type", "i64"});
-auto el_type_i32 = std::pair<std::string, detail::AttrAny>({"element_type", "i32"});
-auto el_type_f32 = std::pair<std::string, detail::AttrAny>({"element_type", "f32"});
+auto el_type_i64 = std::pair<std::string, gen_pattern::detail::AttrAny>({"element_type", "i64"});
+auto el_type_i32 = std::pair<std::string, gen_pattern::detail::AttrAny>({"element_type", "i32"});
+auto el_type_f32 = std::pair<std::string, gen_pattern::detail::AttrAny>({"element_type", "f32"});
 
 // Convert ops attributes:
-auto dest_type_i64 = std::pair<std::string, detail::AttrAny>({"destination_type", "i64"});
-auto dest_type_f32 = std::pair<std::string, detail::AttrAny>({"destination_type", "f32"});
-auto dest_type_f16 = std::pair<std::string, detail::AttrAny>({"destination_type", "f16"});
+auto dest_type_i64 = std::pair<std::string, gen_pattern::detail::AttrAny>({"destination_type", "i64"});
+auto dest_type_f32 = std::pair<std::string, gen_pattern::detail::AttrAny>({"destination_type", "f32"});
+auto dest_type_f16 = std::pair<std::string, gen_pattern::detail::AttrAny>({"destination_type", "f16"});
 
 // Other attributes:
-auto numpy_broadcast = std::pair<std::string, detail::AttrAny>({"auto_broadcast", "numpy"});
-auto special_zero_true = std::pair<std::string, detail::AttrAny>({"special_zero", true});
+auto numpy_broadcast = std::pair<std::string, gen_pattern::detail::AttrAny>({"auto_broadcast", "numpy"});
+auto special_zero_true = std::pair<std::string, gen_pattern::detail::AttrAny>({"special_zero", true});
 
 auto single_val = [](int rank, float val) {
     return makeConst(element::f32, ov::Shape{std::vector<size_t>(rank, 1)}, {val});

src/core/include/openvino/core/except.hpp

@@ -91,6 +91,42 @@ class OPENVINO_API NotImplemented : public AssertFailure {
 protected:
     explicit NotImplemented(const std::string& what_arg) : ov::AssertFailure(what_arg) {}
 };
+
+namespace detail {
+
+template <class T>
+constexpr inline bool check_condition(T&& v) noexcept {
+    return static_cast<bool>(std::forward<T>(v));
+}
+
+template <std::size_t N>
+constexpr inline bool check_condition(const char (&)[N]) noexcept {
+    static_assert(N == 0,
+                  "OPENVINO_ASSERT: string literal used as condition (always true). "
+                  "Did you mean to compare strings or check a pointer?");
+    return false;
+}
+
+template <std::size_t N>
+constexpr inline bool check_condition(const wchar_t (&)[N]) noexcept {
+    static_assert(N == 0, "OPENVINO_ASSERT: wide string literal used as condition (always true).");
+    return false;
+}
+
+template <std::size_t N>
+constexpr inline bool check_condition(const char16_t (&)[N]) noexcept {
+    static_assert(N == 0, "OPENVINO_ASSERT: UTF-16 string literal used as condition (always true).");
+    return false;
+}
+
+template <std::size_t N>
+constexpr inline bool check_condition(const char32_t (&)[N]) noexcept {
+    static_assert(N == 0, "OPENVINO_ASSERT: UTF-32 string literal used as condition (always true).");
+    return false;
+}
+
+}  // namespace detail
+
 }  // namespace ov
 
 //
@@ -157,7 +193,7 @@ class OPENVINO_API NotImplemented : public AssertFailure {
 //
 #define OPENVINO_ASSERT_HELPER2(exc_class, ctx, check, ...)                      \
     do {                                                                         \
-        if (!static_cast<bool>(check)) {                                         \
+        if (!::ov::detail::check_condition(check)) {                             \
             ::std::ostringstream ss___;                                          \
             ::ov::write_all_to_stream(ss___, __VA_ARGS__);                       \
             exc_class::create(__FILE__, __LINE__, (#check), (ctx), ss___.str()); \
@@ -166,7 +202,7 @@ class OPENVINO_API NotImplemented : public AssertFailure {
 
 #define OPENVINO_ASSERT_HELPER1(exc_class, ctx, check)                                      \
     do {                                                                                    \
-        if (!static_cast<bool>(check)) {                                                    \
+        if (!::ov::detail::check_condition(check)) {                                        \
             exc_class::create(__FILE__, __LINE__, (#check), (ctx), exc_class::default_msg); \
         }                                                                                   \
     } while (0)

src/plugins/hetero/src/remote_context.cpp

@@ -14,9 +14,7 @@ namespace hetero {
 
 RemoteContext::RemoteContext(std::map<std::string, ov::SoPtr<ov::IRemoteContext>> contexts)
     : m_contexts(std::move(contexts)) {
-    if (m_contexts.empty()) {
-        OPENVINO_ASSERT("HETERO RemoteContext must have at least one underlying context");
-    }
+    OPENVINO_ASSERT(!m_contexts.empty(), "HETERO RemoteContext must have at least one underlying context");
 }
 const ov::AnyMap& RemoteContext::get_property() const {
     return m_contexts.begin()->second->get_property();

src/plugins/intel_cpu/src/nodes/region_yolo.cpp

@@ -417,7 +417,7 @@ inline void RegionYolo::calculate_logistic(size_t start_index, int count, uint8_
                 bf16_dst_data[i + start_index] = logistic_scalar(bf16_dst_data[i + start_index]);
             }
         } else {
-            CPU_NODE_ASSERT("Unsupported precision configuration outPrc=", output_prec.get_type_name());
+            CPU_NODE_THROW("Unsupported precision configuration outPrc=", output_prec.get_type_name());
         }
     }
 }

src/plugins/intel_gpu/src/graph/common_utils/jitter.cpp

@@ -32,7 +32,7 @@ std::vector<ChannelName> get_data_channels_order(size_t rank) {
     case 8:
         return {channel::BATCH, channel::FEATURE, channel::V, channel::U, channel::W, channel::Z, channel::Y, channel::X};
     default:
-        OPENVINO_ASSERT("[GPU] Unexpected rank ", rank, " in get_data_channels_order() func");
+        OPENVINO_THROW("[GPU] Unexpected rank ", rank, " in get_data_channels_order() func");
     }
 
     return {};

src/plugins/intel_gpu/src/graph/reshape.cpp

@@ -113,12 +113,9 @@ layout reshape_inst::calc_output_layout(reshape_node const& node, kernel_impl_pa
     auto input_layout = impl_param.get_non_padded_input_layout();
     auto desc = impl_param.typed_desc<reshape>();
     if (desc->output_shape.count() == 0) {
-        if (desc->output_partial_shape.size() != 0) {
-            format out_fmt = format::adjust_to_rank(input_layout.format, desc->output_partial_shape.rank().get_length());
-            return layout{desc->output_partial_shape, input_layout.data_type, out_fmt};
-        } else {
-            OPENVINO_ASSERT("[GPU] Output shape is not provided");
-        }
+        OPENVINO_ASSERT(desc->output_partial_shape.size() != 0, "[GPU] Output shape is not provided");
+        format out_fmt = format::adjust_to_rank(input_layout.format, desc->output_partial_shape.rank().get_length());
+        return layout{desc->output_partial_shape, input_layout.data_type, out_fmt};
     }
 
     auto sizes = desc->output_shape.sizes();

src/plugins/intel_gpu/src/kernel_selector/kernels/fully_connected/fully_connected_kernel_gemv.cpp

@@ -162,15 +162,15 @@ JitConstants FullyConnected_GEMV::GetJitConstants(const fully_connected_params&
     } else if (params.weights.GetLayout() == WeightsLayout::os_is_yx_osv64_isv2) {
         jit.AddConstant(MakeJitConstant("FILTER_LAYOUT_OS_IS_YX_TYPE", 2));
     } else {
-        OPENVINO_ASSERT("GEMV doesn't support this weights layout: ", params.weights.GetLayout());
+        OPENVINO_THROW("GEMV doesn't support this weights layout: ", params.weights.GetLayout());
     }
 
     if (params.weights.GetDType() == WeightsType::UINT4) {
         jit.AddConstant(MakeJitConstant("WEI_UINT4", 1));
     } else if (params.weights.GetDType() == WeightsType::INT4) {
         jit.AddConstant(MakeJitConstant("WEI_UINT4", 0));
     } else {
-        OPENVINO_ASSERT("GEMV only support INT4 and UINT4, doesn't support ", static_cast<size_t>(params.weights.GetDType()));
+        OPENVINO_THROW("GEMV only support INT4 and UINT4, doesn't support ", static_cast<size_t>(params.weights.GetDType()));
     }
 
     jit.AddConstant(MakeJitConstant("SIMD", simd));

src/plugins/intel_gpu/src/plugin/transformations/fc_horizontal_fusion.cpp

@@ -256,7 +256,7 @@ FullyConnectedHorizontalFusion::FullyConnectedHorizontalFusion(bool fuse_mlp_swi
                             ov::as_type_ptr<ov::op::v0::Constant>(zp_convert->get_input_node_shared_ptr(0));
                         cur_zp_val = zp_const->cast_vector<int32_t>()[0];
                     } else {
-                        OPENVINO_ASSERT("Unsupported zp input node for FC horizontal fusion");
+                        OPENVINO_THROW("Unsupported zp input node for FC horizontal fusion");
                     }
                     if (cur_zp_val != scalar_zp_val)
                         return false;

src/plugins/intel_gpu/tests/unit/test_cases/moe_gemm_gpu_test.cpp

@@ -139,7 +139,7 @@ void get_reference(const std::vector<ov::float16>& input,
                                 acc += fa0 * input_r[2 * ki];
                                 acc += fa1 * input_r[2 * ki + 1];
                             } else {
-                                OPENVINO_ASSERT("Not implemented dt");
+                                OPENVINO_THROW("Not implemented dt");
                             }
                         }
                         scale_group++;