[CLANG_FORMAT] Force west const (#29944)

It makes sense to have it alligned accross the whole product.
The change is not that big.
Also this helps clang-tidy to apply and format fixes in
consistent style

Author: EgorDuplensky

src/.clang-format

@@ -23,6 +23,7 @@ DerivePointerAlignment: false
 FixNamespaceComments: true
 IndentCaseLabels: false
 IndentPPDirectives: AfterHash
+QualifierAlignment: Left
 ForEachMacros:
   - foreach
   - FOREACH_CHILD

src/bindings/c/src/ov_common.cpp

@@ -7,7 +7,7 @@
  * @variable global value for error info.
  * Don't change its order.
  */
-char const* error_infos[] = {"success",
+const char* error_infos[] = {"success",
                              "general error",
                              "it's not implement",
                              "failed to network",

src/bindings/c/tests/ov_remote_context_test.cpp

@@ -47,11 +47,11 @@ class ov_remote_context_ocl : public ov_capi_test_base {
         std::vector<cl_platform_id> platform_ids(n);
         err = clGetPlatformIDs(n, platform_ids.data(), NULL);
 
-        for (auto const& id : platform_ids) {
+        for (const auto& id : platform_ids) {
             cl::Platform platform = cl::Platform(id);
             std::vector<cl::Device> devices;
             platform.getDevices(CL_DEVICE_TYPE_GPU, &devices);
-            for (auto const& d : devices) {
+            for (const auto& d : devices) {
                 if (refVendorID == d.getInfo<CL_DEVICE_VENDOR_ID>()) {
                     cl_device = d;
                     cl_context = cl::Context(cl_device);

src/bindings/js/node/src/async_reader.cpp

@@ -22,7 +22,7 @@ void ReaderWorker::OnOK() {
     _deferred.Resolve(model);
 }
 
-void ReaderWorker::OnError(Napi::Error const& error) {
+void ReaderWorker::OnError(const Napi::Error& error) {
     _deferred.Reject(error.Value());
 }
 

src/common/conditional_compilation/include/openvino/cc/factory.h

@@ -20,8 +20,8 @@ class Factory;
 
 template <typename Key, typename T, typename... Args>
 class Factory<Key, T(Args...)> {
-    Factory(Factory const&) = delete;
-    Factory& operator=(Factory const&) = delete;
+    Factory(const Factory&) = delete;
+    Factory& operator=(const Factory&) = delete;
 
 public:
     using builder_t = std::function<T(Args...)>;

src/common/conditional_compilation/include/openvino/cc/selective_build.h

@@ -132,7 +132,7 @@ case_wrapper<C, T> make_case_wrapper(C&& val, const char* name) {
 }
 
 template <openvino::itt::domain_t (*domain)(), template <typename...> class Fn, typename Ctx, typename T, typename Case>
-bool match(char const* region, Ctx&& ctx, T&& val, Case&& cs) {
+bool match(const char* region, Ctx&& ctx, T&& val, Case&& cs) {
     const bool is_matched = val == cs.value;
     if (is_matched) {
         openvino::itt::ScopedTask<domain> task(openvino::itt::handle(std::string(region) + "$" + cs.name));
@@ -148,7 +148,7 @@ template <openvino::itt::domain_t (*domain)(),
           typename T,
           typename Case,
           typename... Cases>
-bool match(char const* region, Ctx&& ctx, T&& val, Case&& cs, Cases&&... cases) {
+bool match(const char* region, Ctx&& ctx, T&& val, Case&& cs, Cases&&... cases) {
     if (match<domain, Fn>(region, std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Case>(cs)))
         return true;
     return match<domain, Fn>(region, std::forward<Ctx>(ctx), std::forward<T>(val), std::forward<Cases>(cases)...);

src/common/itt/include/openvino/itt.hpp

@@ -41,8 +41,8 @@ typedef struct handle_ {
  * @cond
  */
 namespace internal {
-domain_t domain(char const* name);
-handle_t handle(char const* name);
+domain_t domain(const char* name);
+handle_t handle(const char* name);
 void taskBegin(domain_t d, handle_t t);
 void taskEnd(domain_t d);
 void threadName(const char* name);
@@ -65,7 +65,7 @@ inline void threadName(const std::string& name) {
     internal::threadName(name.c_str());
 }
 
-inline handle_t handle(char const* name) {
+inline handle_t handle(const char* name) {
     return internal::handle(name);
 }
 
@@ -81,7 +81,7 @@ inline handle_t handle(const std::string& name) {
  * @param name [in] The annotation name
  */
 template <typename Tag>
-handle_t handle(char const* name) {
+handle_t handle(const char* name) {
     static auto h = internal::handle(name);
     return h;
 }

src/common/itt/src/itt.cpp

@@ -24,11 +24,11 @@ static size_t callStackDepth() {
 
 static thread_local uint32_t call_stack_depth = 0;
 
-domain_t domain(char const* name) {
+domain_t domain(const char* name) {
     return reinterpret_cast<domain_t>(__itt_domain_create(name));
 }
 
-handle_t handle(char const* name) {
+handle_t handle(const char* name) {
     return reinterpret_cast<handle_t>(__itt_string_handle_create(name));
 }
 
@@ -51,11 +51,11 @@ void threadName(const char* name) {
 
 #else
 
-domain_t domain(char const*) {
+domain_t domain(const char*) {
     return nullptr;
 }
 
-handle_t handle(char const*) {
+handle_t handle(const char*) {
     return nullptr;
 }
 

src/common/util/include/openvino/util/common_util.hpp

@@ -150,7 +150,7 @@ bool contains(const R& container, const V& value) {
  * @return result of multiplication
  */
 template <typename T, typename A>
-T product(std::vector<T, A> const& vec) {
+T product(const std::vector<T, A>& vec) {
     return vec.empty() ? T{0} : std::accumulate(vec.begin(), vec.end(), T{1}, std::multiplies<T>());
 }
 

src/core/reference/include/openvino/reference/autobroadcast_binop.hpp

@@ -126,7 +126,7 @@ void numpy_broadcast_binop(const T* arg0,
     //                 [ 3, 2, 6]
     using namespace internal;
 
-    size_t const shape_rank = std::max(arg0_shape.size(), arg1_shape.size()) + 1;
+    const size_t shape_rank = std::max(arg0_shape.size(), arg1_shape.size()) + 1;
 
     // TODO: Use compiler-specific alloca() or variable-length array
     std::vector<size_t> tmp(shape_rank * 2);
@@ -137,16 +137,16 @@ void numpy_broadcast_binop(const T* arg0,
     row_major_strides(arg0_shape, strides0, shape_rank);
     row_major_strides(arg1_shape, strides1, shape_rank);
 
-    size_t const padding0 = shape_rank - arg0_shape.size();
-    size_t const padding1 = shape_rank - arg1_shape.size();
+    const size_t padding0 = shape_rank - arg0_shape.size();
+    const size_t padding1 = shape_rank - arg1_shape.size();
 
     Shape output_shape(shape_rank, 0);
 
     size_t axis = 0;
 
     for (size_t i = 0; i < shape_rank; ++i) {
-        auto const dim0 = value_with_padding_or(arg0_shape, padding0, i, 1);
-        auto const dim1 = value_with_padding_or(arg1_shape, padding1, i, 1);
+        const auto dim0 = value_with_padding_or(arg0_shape, padding0, i, 1);
+        const auto dim1 = value_with_padding_or(arg1_shape, padding1, i, 1);
 
         output_shape[i] = std::max(dim0, dim1);
 

src/core/reference/src/op/einsum.cpp

@@ -1040,7 +1040,7 @@ void einsum_impl(const ov::TensorVector& inputs, ov::TensorVector& outputs, cons
     fix_inputs_with_0d_ellipsis<T>(int_inputs, input_subscripts, output_subscript);
 
     // contract inputs by Einsum until just one is remained
-    for (auto const& inds_pair : einsum_path) {
+    for (const auto& inds_pair : einsum_path) {
         contract_two_inputs<T>(int_inputs, input_subscripts, output_subscript, inds_pair.first, inds_pair.second);
     }
 

src/core/reference/src/utils/coordinate_transform.cpp

@@ -35,7 +35,7 @@ CoordinateIterator::CoordinateIterator(const Shape& target_shape, bool is_end)
       m_coordinate(target_shape.size(), 0) {
     // The case where we have a zero-length axis is a bit special, in that
     // the iterator always starts out of bounds.
-    bool const empty = std::find(target_shape.begin(), target_shape.end(), 0) != target_shape.end();
+    const bool empty = std::find(target_shape.begin(), target_shape.end(), 0) != target_shape.end();
 
     m_oob = is_end || empty;
 }

src/core/shape_inference/include/einsum_shape_inference.hpp

@@ -49,7 +49,7 @@ std::vector<TRShape> shape_infer(const Einsum* op, const std::vector<T>& input_s
                 "corresponding input subscript.");
             std::unordered_map<std::string, TRShape> single_input_label_to_shape;
             for (size_t label_ind = 0, dim_ind = 0; label_ind < labels.size() && dim_ind < input_rank; ++label_ind) {
-                auto const& label = labels[label_ind];
+                const auto& label = labels[label_ind];
                 if (label.compare("...") == 0) {
                     size_t num_broadcasted_dims = input_rank - labels.size() + 1;
                     auto current_sub_pshape = T(std::vector<DimType>(pshape.begin() + dim_ind,
@@ -100,7 +100,7 @@ std::vector<TRShape> shape_infer(const Einsum* op, const std::vector<T>& input_s
                 // Shape has dynamic rank and ellipsis
                 return {pshape};
             }
-            for (auto const& label : labels) {
+            for (const auto& label : labels) {
                 if (label_to_shape.find(label) == label_to_shape.end()) {
                     label_to_shape[label] = ov::PartialShape{Dimension::dynamic()};
                 }
@@ -112,7 +112,7 @@ std::vector<TRShape> shape_infer(const Einsum* op, const std::vector<T>& input_s
     auto output_shapes = std::vector<TRShape>(1);
     auto& output_shape = output_shapes[0];
 
-    for (auto const& output_label : output_labels) {
+    for (const auto& output_label : output_labels) {
         if (output_label == "..." && label_to_shape.find(output_label) == label_to_shape.end()) {
             // Output labels may contain ellipsis that does not cover any dimensions.
             continue;

src/core/shape_inference/include/eye_shape_inference.hpp

@@ -27,7 +27,7 @@ void check_1D_or_scalar_shape(const ov::op::v9::Eye* op, const T& input_shape, c
 }  // namespace util
 
 namespace eye {
-constexpr std::array<char const*, 4> shape_names{"'num_rows'", "'num_columns'", "'diagonal_index'", "'batch_shape'"};
+constexpr std::array<const char*, 4> shape_names{"'num_rows'", "'num_columns'", "'diagonal_index'", "'batch_shape'"};
 }
 
 namespace v9 {

src/core/shape_inference/include/prior_box_shape_inference_util.hpp

@@ -12,7 +12,7 @@
 namespace ov {
 namespace op {
 namespace prior_box {
-constexpr std::array<char const*, 2> input_names{"output size", "image"};
+constexpr std::array<const char*, 2> input_names{"output size", "image"};
 
 namespace validate {
 inline std::vector<PartialShape> inputs_et(const Node* const op) {

src/core/shape_inference/include/slice_shape_inference.hpp

@@ -15,7 +15,7 @@ namespace op {
 
 namespace slice {
 
-constexpr std::array<char const*, 4> shape_names{"start", "stop", "step", "axes"};
+constexpr std::array<const char*, 4> shape_names{"start", "stop", "step", "axes"};
 
 struct AxesMap {
     bool is_valid{};               //!< Flag indicates current axes map has valid data (unique).

src/core/shape_inference/include/strided_slice_shape_inference.hpp

@@ -20,7 +20,7 @@ std::vector<TRShape> shape_infer(const StridedSlice* op,
                                  const std::vector<T>& input_shapes,
                                  const ITensorAccessor& ta = make_tensor_accessor()) {
     using DimType = typename T::value_type;
-    static constexpr std::array<char const*, 3> shape_names{"Begin", "End", "Strides"};
+    static constexpr std::array<const char*, 3> shape_names{"Begin", "End", "Strides"};
 
     NODE_VALIDATION_CHECK(op, (input_shapes.size() == 3 || input_shapes.size() == 4));
 

src/core/src/op/batch_to_space.cpp

@@ -72,7 +72,7 @@ bool batch_to_space_evaluate(TensorVector& outputs, const TensorVector& inputs)
 
     auto data_shape = in.get_shape();
 
-    auto const block_values_size = shape_size(inputs[1].get_shape());
+    const auto block_values_size = shape_size(inputs[1].get_shape());
 
     const auto* block_values = inputs[1].data<int64_t>();
     const auto* crops_begin_values = inputs[2].data<int64_t>();

src/core/src/op/einsum.cpp

@@ -120,8 +120,8 @@ void op::v7::Einsum::parse_equation(const std::string& equation,
         // equation is in implicit mode so recover output subscript
         output_subscript = "";
         for (size_t ind = 0; ind < input_subscripts.size(); ++ind) {
-            auto const& input_subscript = input_subscripts[ind];
-            for (auto const& label : extract_labels(input_subscript)) {
+            const auto& input_subscript = input_subscripts[ind];
+            for (const auto& label : extract_labels(input_subscript)) {
                 if (label != ellipsis && (is_label_elsewhere(input_subscripts, label, {ind}) == false)) {
                     output_subscript += label;
                 }

src/core/src/pass/perf_counters.cpp

@@ -5,7 +5,7 @@
 
 namespace ov {
 namespace pass {
-openvino::itt::handle_t PerfCounters::operator[](ov::Node::type_info_t const& type_inf) {
+openvino::itt::handle_t PerfCounters::operator[](const ov::Node::type_info_t& type_inf) {
     std::lock_guard<std::mutex> guard(m_mutex);
     auto it = m_counters.find(&type_inf);
     if (it != m_counters.end())

src/core/src/pass/perf_counters.hpp

@@ -12,16 +12,16 @@
 namespace ov {
 namespace pass {
 class PerfCounters {
-    PerfCounters(PerfCounters const&) = delete;
-    PerfCounters& operator=(PerfCounters const&) = delete;
+    PerfCounters(const PerfCounters&) = delete;
+    PerfCounters& operator=(const PerfCounters&) = delete;
 
 public:
     PerfCounters() = default;
 
-    openvino::itt::handle_t operator[](ov::Node::type_info_t const& type_inf);
+    openvino::itt::handle_t operator[](const ov::Node::type_info_t& type_inf);
 
 private:
-    using key = ov::Node::type_info_t const*;
+    using key = const ov::Node::type_info_t*;
     using value = openvino::itt::handle_t;
     using counters_map = std::unordered_map<key, value>;
 

src/core/src/pass/serialize.cpp

@@ -88,7 +88,7 @@ class ConstantWriter {
 public:
     using FilePosition = int64_t;
     using HashValue = size_t;
-    using ConstWritePositions = std::multimap<HashValue, std::pair<FilePosition, void const*>>;
+    using ConstWritePositions = std::multimap<HashValue, std::pair<FilePosition, const void*>>;
 
     ConstantWriter(std::ostream& bin_data, bool enable_compression = true)
         : m_binary_output(bin_data),
@@ -146,7 +146,7 @@ class ConstantWriter {
             if (!ptr_is_temporary) {
                 // Since fp16_compressed data will be disposed at exit point and since we cannot reread it from the
                 // ostream, we store pointer to the original uncompressed blob.
-                m_hash_to_file_positions.insert({hash, {offset, static_cast<void const*>(ptr)}});
+                m_hash_to_file_positions.insert({hash, {offset, static_cast<const void*>(ptr)}});
             }
             if (m_write_hash_value) {
                 m_binary_output.write(reinterpret_cast<const char*>(&hash), sizeof(uint64_t));

src/core/tests/constant.cpp

@@ -895,7 +895,7 @@ TEST(constant, uint2_string_broadcast) {
 }
 
 TEST(constant, uint2_vector_less_than_single_byte) {
-    auto const shape = Shape{3};
+    const auto shape = Shape{3};
     const auto input = std::vector<uint8_t>{2, 3, 1};
 
     op::v0::Constant c(element::u2, shape, input);
@@ -909,7 +909,7 @@ TEST(constant, uint2_vector_less_than_single_byte) {
 }
 
 TEST(constant, uint2_vector_bigger_than_single_byte) {
-    auto const shape = Shape{7};
+    const auto shape = Shape{7};
     const auto input = std::vector<uint8_t>{2, 3, 1, 0, 1, 2, 0};
 
     op::v0::Constant c(element::u2, shape, input);
@@ -1007,7 +1007,7 @@ TEST(constant, uint3_string_broadcast) {
 }
 
 TEST(constant, uint3_vector_less_than_one_storage_unit) {
-    auto const shape = Shape{3};
+    const auto shape = Shape{3};
     const auto input = std::vector<uint8_t>{5, 3, 1};
 
     op::v0::Constant c(element::u3, shape, input);
@@ -1023,7 +1023,7 @@ TEST(constant, uint3_vector_less_than_one_storage_unit) {
 }
 
 TEST(constant, uint3_vector_greater_than_one_storage_unit) {
-    auto const shape = Shape{10};
+    const auto shape = Shape{10};
     const auto input = std::vector<uint8_t>{2, 3, 1, 0, 4, 5, 6, 7, 5, 2};
 
     op::v0::Constant c(element::u3, shape, input);
@@ -1247,7 +1247,7 @@ TEST(constant, uint6_string_broadcast) {
 }
 
 TEST(constant, uint6_vector_less_than_one_storage_unit) {
-    auto const shape = Shape{3};
+    const auto shape = Shape{3};
     const auto input = std::vector<uint8_t>{5, 23, 1};
 
     op::v0::Constant c(element::u6, shape, input);
@@ -1263,7 +1263,7 @@ TEST(constant, uint6_vector_less_than_one_storage_unit) {
 }
 
 TEST(constant, uint6_vector_greater_than_one_storage_unit) {
-    auto const shape = Shape{6};
+    const auto shape = Shape{6};
     const auto input = std::vector<uint8_t>{25, 3, 1, 0, 45, 5};
 
     op::v0::Constant c(element::u6, shape, input);

src/frontends/ir/src/ir_deserializer.cpp

@@ -558,7 +558,7 @@ std::shared_ptr<ov::Model> ov::XmlDeserializer::parse_function(const pugi::xml_n
                 OPENVINO_THROW("Attempt to access node ", e.fromLayerId, " that not in graph.");
             }
             auto& p_output = params[e.fromLayerId].params;
-            size_t const realInputPortId = p.params.get_real_input_port_id(e.toPortId);
+            const size_t realInputPortId = p.params.get_real_input_port_id(e.toPortId);
             if (realInputPortId >= inputs.size())
                 OPENVINO_THROW(p.params.type,
                                " layer ",
@@ -911,7 +911,7 @@ std::shared_ptr<ov::Node> ov::XmlDeserializer::create_node(const std::vector<ov:
             }
         }
 
-        auto const& opset = opsetIt->second;
+        const auto& opset = opsetIt->second;
 
         ovNode = std::shared_ptr<ov::Node>(opset.create_insensitive(type_name));
         if (!ovNode) {

src/frontends/onnx/frontend/src/core/model.hpp

@@ -103,7 +103,7 @@ class Model {
     std::int64_t get_opset_version(const std::string& domain) {
         try {
             return ov::frontend::onnx::get_opset_version(*this->m_model_proto, domain);
-        } catch (ov::Exception const&) {
+        } catch (const ov::Exception&) {
             return -1;
         }
     }