Address 'modernize-use-nodiscard' clang-tidy remarks (#251)

aobolensk · web-flow · commit d6d165822bd5 · 2025-12-15T10:47:50.000+01:00
diff --git a/.clang-tidy b/.clang-tidy
@@ -15,7 +15,6 @@ Checks: >
   -modernize-return-braced-init-list,
   -modernize-use-trailing-return-type,
   -modernize-concat-nested-namespaces,
-  -modernize-use-nodiscard,
   -modernize-avoid-c-arrays,
   -modernize-pass-by-value,
   -performance-move-const-arg,
diff --git a/include/graph/graph.hpp b/include/graph/graph.hpp
@@ -96,30 +96,30 @@ class Graph {
     return raw_ptr;
   }
 
-  int getVertexValue(size_t layerID) const {
+  [[nodiscard]] int getVertexValue(size_t layerID) const {
     if (layerID >= arrayV_.size()) {
       throw std::invalid_argument("ArrayV does not contain this ID.");
     }
     return arrayV_[layerID];
   }
 
-  int getEdgeValue(size_t pos) const {
+  [[nodiscard]] int getEdgeValue(size_t pos) const {
     if (pos >= arrayE_.size()) {
       throw std::invalid_argument("ArrayE does not contain this.");
     }
     return arrayE_[pos];
   }
 
-  size_t getInputsSize(size_t layerID) const {
+  [[nodiscard]] size_t getInputsSize(size_t layerID) const {
     if (layerID >= in_edges_.size()) {
       throw std::invalid_argument("Input edges array do not contain this ID.");
     }
     return in_edges_[layerID].size();
   }
 
-  int getLayersCount() const { return V_; }
+  [[nodiscard]] int getLayersCount() const { return V_; }
 
-  const Layer& getLayerFromID(size_t layerID) const {
+  [[nodiscard]] const Layer& getLayerFromID(size_t layerID) const {
     if (layerID >= layers_.size()) {
       throw std::invalid_argument("Layers do not contain this ID.");
     }
@@ -376,7 +376,7 @@ class Graph {
   std::vector<Tensor> getWEIGHTS() { return weights_; }
 #endif
 
-  std::vector<std::pair<int, int>> getInOutDegrees() const {
+  [[nodiscard]] std::vector<std::pair<int, int>> getInOutDegrees() const {
     std::vector<int> in_degree(V_, 0);
 
     for (int i = 0; i < V_; ++i) {
@@ -397,7 +397,7 @@ class Graph {
     return result;
   }
 
-  std::vector<int> getTraversalOrder() const {
+  [[nodiscard]] std::vector<int> getTraversalOrder() const {
     auto in_out_degrees = getInOutDegrees();
     std::vector<int> in_degree(V_);
     for (int i = 0; i < V_; ++i) {
diff --git a/include/layers/ConcatLayer.hpp b/include/layers/ConcatLayer.hpp
@@ -25,9 +25,11 @@ class ConcatLayer : public Layer {
   int64_t axis_;
   std::vector<int> input_order_;
   void validate_inputs(const std::vector<Tensor>& inputs) const;
-  int64_t normalize_axis(size_t rank) const;
-  Shape calculate_output_shape(const std::vector<Tensor>& inputs) const;
-  std::vector<Tensor> reorderInputs(const std::vector<Tensor>& inputs) const;
+  [[nodiscard]] int64_t normalize_axis(size_t rank) const;
+  [[nodiscard]] Shape calculate_output_shape(
+      const std::vector<Tensor>& inputs) const;
+  [[nodiscard]] std::vector<Tensor> reorderInputs(
+      const std::vector<Tensor>& inputs) const;
   template <typename T>
   void concatenate(const std::vector<Tensor>& inputs, Tensor& output) const {
     std::vector<Tensor> ordered_inputs = reorderInputs(inputs);
diff --git a/include/layers/ConvLayer.hpp b/include/layers/ConvLayer.hpp
@@ -86,15 +86,17 @@ class ConvImpl : public LayerImpl<ValueType> {
 
   ConvImpl(const ConvImpl& c) = default;
 
-  std::vector<ValueType> run(
+  [[nodiscard]] std::vector<ValueType> run(
       const std::vector<ValueType>& input) const override {
     return input;
   }
 
-  std::vector<ValueType> run(std::vector<ValueType> startmatrix, int new_rows,
-                             int new_cols, std::vector<ValueType> startkernel,
-                             size_t start_kernel_size, size_t kernel_size,
-                             int center_distance) const {
+  [[nodiscard]] std::vector<ValueType> run(std::vector<ValueType> startmatrix,
+                                           int new_rows, int new_cols,
+                                           std::vector<ValueType> startkernel,
+                                           size_t start_kernel_size,
+                                           size_t kernel_size,
+                                           int center_distance) const {
     std::vector<ValueType> matrix(new_rows * new_cols * input_flow_, 0);
     for (int i = 0; i < input_height_; ++i) {
       for (int j = 0; j < input_width_; ++j) {
@@ -125,14 +127,14 @@ class ConvImpl : public LayerImpl<ValueType> {
             if (input_width_ == 0) {
               throw std::out_of_range("Input = 0");
             }
-            int kercol_index = coloms / input_width_ + 1;
-            if (kercol_index < 0) {
-              throw std::out_of_range("Kernel column index is negative");
-            }
-            auto kercol = static_cast<size_t>(kercol_index);
-            color +=
-                matrix[(i + coloms + str) * input_flow_ + x] *
-                kernel[kercol * kernel_size + static_cast<size_t>(str + 1)];
+            int kercol_index = coloms / input_width_ + 1;
+            if (kercol_index < 0) {
+              throw std::out_of_range("Kernel column index is negative");
+            }
+            auto kercol = static_cast<size_t>(kercol_index);
+            color +=
+                matrix[(i + coloms + str) * input_flow_ + x] *
+                kernel[kercol * kernel_size + static_cast<size_t>(str + 1)];
           }
         }
         if (!bias_.empty() && static_cast<size_t>(x) < bias_.size()) {
diff --git a/include/layers/FCLayer.hpp b/include/layers/FCLayer.hpp
@@ -84,7 +84,7 @@ class FCLayerImpl : public LayerImpl<ValueType> {
     }
     weights_[i * this->inputShape_[0] + j] = value;
   }
-  ValueType get_weight(size_t i, size_t j) const {
+  [[nodiscard]] ValueType get_weight(size_t i, size_t j) const {
     if (i >= this->outputShape_[0] || j >= this->inputShape_[0]) {
       throw std::out_of_range("Invalid weight index");
     }
@@ -96,7 +96,7 @@ class FCLayerImpl : public LayerImpl<ValueType> {
     }
     bias_[i] = value;
   }
-  ValueType get_bias(size_t i) const {
+  [[nodiscard]] ValueType get_bias(size_t i) const {
     if (i >= this->outputShape_[0]) {
       throw std::out_of_range("Invalid bias index");
     }
diff --git a/include/layers/Layer.hpp b/include/layers/Layer.hpp
@@ -52,11 +52,13 @@ class Layer {
   explicit Layer(LayerType type) : type_(type) {}
   virtual ~Layer() = default;
   PostOperations postops;
-  int getID() const { return id_; }
+  [[nodiscard]] int getID() const { return id_; }
   void setID(int id) { id_ = id; }
   void setParallelBackend(ParBackend backend) { parallel_backend_ = backend; }
-  ParBackend getParallelBackend() const { return parallel_backend_; }
-  LayerType getName() const { return type_; }
+  [[nodiscard]] ParBackend getParallelBackend() const {
+    return parallel_backend_;
+  }
+  [[nodiscard]] LayerType getName() const { return type_; }
   virtual void run(const std::vector<Tensor>& input,
                    std::vector<Tensor>& output) = 0;
 #ifdef ENABLE_STATISTIC_WEIGHTS
@@ -77,12 +79,12 @@ class LayerImpl {
       : inputShape_(inputShape), outputShape_(outputShape) {}
   LayerImpl(const LayerImpl& c) = default;
   LayerImpl& operator=(const LayerImpl& c) = default;
-  virtual std::vector<ValueType> run(
+  [[nodiscard]] virtual std::vector<ValueType> run(
       const std::vector<ValueType>& input) const = 0;
-  Shape get_input_shape() const { return inputShape_; }
-  Shape get_output_shape() const { return outputShape_; }
+  [[nodiscard]] Shape get_input_shape() const { return inputShape_; }
+  [[nodiscard]] Shape get_output_shape() const { return outputShape_; }
   // weights width x height
-  std::pair<Shape, Shape> get_dims() const {
+  [[nodiscard]] std::pair<Shape, Shape> get_dims() const {
     return std::pair<Shape, Shape>(outputShape_, inputShape_);
   }
 
diff --git a/include/layers/OutputLayer.hpp b/include/layers/OutputLayer.hpp
@@ -18,9 +18,9 @@ class OutputLayer : public Layer {
            std::vector<Tensor>& output) override {
     output = input;
   }
-  std::vector<std::string> get_labels() const { return labels_; }
-  std::pair<std::vector<std::string>, Tensor> top_k(const Tensor& input,
-                                                    size_t k) const;
+  [[nodiscard]] std::vector<std::string> get_labels() const { return labels_; }
+  [[nodiscard]] std::pair<std::vector<std::string>, Tensor> top_k(
+      const Tensor& input, size_t k) const;
 #ifdef ENABLE_STATISTIC_WEIGHTS
   Tensor get_weights() override {
     std::vector<int> v = {0};
diff --git a/include/layers/ReduceLayer.hpp b/include/layers/ReduceLayer.hpp
@@ -32,8 +32,8 @@ class ReduceLayer : public Layer {
 
   static void normalize_axes(const Shape& input_shape,
                              std::vector<int64_t>& axes);
-  Shape calculate_output_shape(const Shape& input_shape,
-                               const std::vector<int64_t>& axes) const;
+  [[nodiscard]] Shape calculate_output_shape(
+      const Shape& input_shape, const std::vector<int64_t>& axes) const;
 
   template <typename T>
   void compute(const Tensor& input, const Shape& output_shape,
diff --git a/include/layers/Shape.hpp b/include/layers/Shape.hpp
@@ -20,7 +20,7 @@ class Shape {
   Shape& operator=(const Shape& c) = default;
   size_t operator[](size_t i) const noexcept { return dims_[i]; }
   size_t& operator[](size_t i) noexcept { return dims_[i]; }
-  size_t at(size_t i) const {
+  [[nodiscard]] size_t at(size_t i) const {
     if (i >= dims_.size()) {
       throw std::out_of_range("Invalid shape index");
     }
@@ -33,12 +33,12 @@ class Shape {
     return dims_[i];
   }
   void resize(const std::vector<size_t>& new_size) { dims_ = new_size; }
-  size_t count() const {
+  [[nodiscard]] size_t count() const {
     return std::accumulate(dims_.begin(), dims_.end(), static_cast<size_t>(1),
                            std::multiplies<>());
   }
-  size_t dims() const noexcept { return dims_.size(); }
-  size_t get_index(const std::vector<size_t>& coords) const;
+  [[nodiscard]] size_t dims() const noexcept { return dims_.size(); }
+  [[nodiscard]] size_t get_index(const std::vector<size_t>& coords) const;
   bool operator==(const Shape& other) const {
     if (dims_.size() != other.dims_.size()) return false;
     for (size_t i = 0; i < dims_.size(); ++i) {
diff --git a/include/layers/SoftmaxLayer.hpp b/include/layers/SoftmaxLayer.hpp
@@ -21,7 +21,7 @@ class SoftmaxLayer : public Layer {
 #endif
 
   void set_axis(int axis) { axis_ = axis; }
-  int get_axis() const { return axis_; }
+  [[nodiscard]] int get_axis() const { return axis_; }
 
  private:
   int axis_;
diff --git a/include/layers/SplitLayer.hpp b/include/layers/SplitLayer.hpp
@@ -28,7 +28,7 @@ class SplitLayer : public Layer {
   std::optional<int> num_outputs_;
 
   void validate(const Tensor& input) const;
-  int get_normalized_axis(int rank) const;
+  [[nodiscard]] int get_normalized_axis(int rank) const;
   template <typename T>
   void split_impl(const Tensor& input, std::vector<Tensor>& outputs) const;
 };
diff --git a/include/layers/Tensor.hpp b/include/layers/Tensor.hpp
@@ -91,8 +91,8 @@ class Tensor {
   Tensor& operator=(Tensor&& t) = default;
   Tensor& operator=(const Tensor& t) = default;
 
-  Shape get_shape() const { return shape_; }
-  Type get_type() const noexcept { return type_; }
+  [[nodiscard]] Shape get_shape() const { return shape_; }
+  [[nodiscard]] Type get_type() const noexcept { return type_; }
 
   void set_bias(const std::vector<float>& bias) {
     if (bias.size() != shape_[shape_.dims() - 1]) {
@@ -102,17 +102,19 @@ class Tensor {
     bias_ = bias;
   }
 
-  const std::vector<float>& get_bias() const { return bias_; }
-  const std::vector<uint8_t>& get_values() const { return values_; }
+  [[nodiscard]] const std::vector<float>& get_bias() const { return bias_; }
+  [[nodiscard]] const std::vector<uint8_t>& get_values() const {
+    return values_;
+  }
 
-  bool empty() const { return values_.empty(); }
+  [[nodiscard]] bool empty() const { return values_.empty(); }
   auto begin() { return values_.begin(); }
 
   auto end() { return values_.end(); }
 
-  auto begin() const { return values_.begin(); }
+  [[nodiscard]] auto begin() const { return values_.begin(); }
 
-  auto end() const { return values_.end(); }
+  [[nodiscard]] auto end() const { return values_.end(); }
 
   template <typename T>
   typename std::vector<T>::const_iterator begin() const {
diff --git a/include/layers_oneDNN/EWLayer.hpp b/include/layers_oneDNN/EWLayer.hpp
@@ -35,7 +35,7 @@ class EwLayerOneDnn : public Layer {
 
  private:
   void initialize_onednn(const Shape& shape, Type data_type);
-  dnnl::algorithm get_algorithm() const;
+  [[nodiscard]] dnnl::algorithm get_algorithm() const;
   void validate_input(const std::vector<Tensor>& input) const;
 
   std::string func_;
diff --git a/src/layers_oneDNN/EWLayer.cpp b/src/layers_oneDNN/EWLayer.cpp
@@ -116,7 +116,7 @@ void EwLayerOneDnn::initialize_onednn(const Shape& shape, Type data_type) {
     if (data_type == Type::kFloat) {
       dnnl_data_type = dnnl::memory::data_type::f32;
     } else {
-      dnnl_data_type = dnnl::memory::data_type::f32;
+      throw std::invalid_argument("Unsupported data type for oneDNN EW layer");
     }
 
     memory_desc_ = dnnl::memory::desc(dims, dnnl_data_type, format);
diff --git a/test/graph/test_graph.cpp b/test/graph/test_graph.cpp
@@ -200,22 +200,26 @@ TEST(graph, set_output_null_layer) {
 
 TEST(graph, get_vertex_value_invalid_id) {
   Graph graph;
-  EXPECT_THROW(graph.getVertexValue(1000), std::invalid_argument);
+  EXPECT_THROW(static_cast<void>(graph.getVertexValue(1000)),
+               std::invalid_argument);
 }
 
 TEST(graph, get_edge_value_invalid_pos) {
   Graph graph;
-  EXPECT_THROW(graph.getEdgeValue(1000), std::invalid_argument);
+  EXPECT_THROW(static_cast<void>(graph.getEdgeValue(1000)),
+               std::invalid_argument);
 }
 
 TEST(graph, get_inputs_size_invalid_id) {
   Graph graph;
-  EXPECT_THROW(graph.getInputsSize(1000), std::invalid_argument);
+  EXPECT_THROW(static_cast<void>(graph.getInputsSize(1000)),
+               std::invalid_argument);
 }
 
 TEST(graph, get_layer_from_id_invalid_id) {
   Graph graph;
-  EXPECT_THROW(graph.getLayerFromID(1000), std::invalid_argument);
+  EXPECT_THROW(static_cast<void>(graph.getLayerFromID(1000)),
+               std::invalid_argument);
 }
 
 TEST(graph, complex_graph_with_split_distribution) {
@@ -283,7 +287,7 @@ TEST(graph, vertex_out_of_range) {
   graph.makeConnection(fcLayer_ptr, fcLayer4_ptr);
   graph.setOutput(fcLayer4_ptr, output);
 
-  ASSERT_ANY_THROW(graph.getVertexValue(5));
+  ASSERT_ANY_THROW(static_cast<void>(graph.getVertexValue(5)));
 }
 
 TEST(graph, edges_out_of_range) {
@@ -310,7 +314,7 @@ TEST(graph, edges_out_of_range) {
   graph.makeConnection(fcLayer_ptr, fcLayer4_ptr);
   graph.setOutput(fcLayer4_ptr, output);
 
-  ASSERT_ANY_THROW(graph.getEdgeValue(999));
+  ASSERT_ANY_THROW(static_cast<void>(graph.getEdgeValue(999)));
 }
 
 TEST(graph, inputs_out_of_range) {
@@ -337,7 +341,7 @@ TEST(graph, inputs_out_of_range) {
   graph.makeConnection(fcLayer_ptr, fcLayer4_ptr);
   graph.setOutput(fcLayer4_ptr, output);
 
-  ASSERT_ANY_THROW(graph.getInputsSize(999));
+  ASSERT_ANY_THROW(static_cast<void>(graph.getInputsSize(999)));
 }
 
 TEST(graph, get_layer_out_of_range) {
@@ -364,7 +368,7 @@ TEST(graph, get_layer_out_of_range) {
   graph.makeConnection(fcLayer_ptr, fcLayer4_ptr);
   graph.setOutput(fcLayer4_ptr, output);
 
-  ASSERT_ANY_THROW(graph.getLayerFromID(999));
+  ASSERT_ANY_THROW(static_cast<void>(graph.getLayerFromID(999)));
 }
 
 TEST(graph_transformations, check_subgraphs_search) {
@@ -633,4 +637,4 @@ TEST(graph_transformations, check_subgraphs_big_random) {
   double res1_time =
       elapsed_time_avg<double, std::milli>(10, find_subgraphs, graph, subgraph);
   std::cerr << "Find subgraphs time in ms " << res1_time << '\n';
-}
+}
diff --git a/test/single_layer/test_fclayer.cpp b/test/single_layer/test_fclayer.cpp
@@ -94,8 +94,8 @@ TEST(fclayer, set_get_weight_throws_when_out_of_range) {
   Shape wshape({3, 3});
   std::vector<double> bias = {0.5, 0.5, 1.0};
   FCLayerImpl<double> layer(a1, wshape, bias);
-  ASSERT_ANY_THROW(layer.get_weight(4, 0));
-  ASSERT_ANY_THROW(layer.get_weight(0, 4));
+  ASSERT_ANY_THROW(static_cast<void>(layer.get_weight(4, 0)));
+  ASSERT_ANY_THROW(static_cast<void>(layer.get_weight(0, 4)));
   ASSERT_ANY_THROW(layer.set_weight(4, 0, 1.3));
   ASSERT_ANY_THROW(layer.set_weight(0, 4, 1.3));
 }
@@ -104,7 +104,7 @@ TEST(fclayer, set_get_bias_throws_when_out_of_range) {
   Shape wshape({3, 3});
   std::vector<double> bias = {0.5, 0.5, 1.0};
   FCLayerImpl<double> layer(a1, wshape, bias);
-  ASSERT_ANY_THROW(layer.get_bias(4));
+  ASSERT_ANY_THROW(static_cast<void>(layer.get_bias(4)));
   ASSERT_ANY_THROW(layer.set_bias(4, 1.3));
 }
 

Original file line number	Diff line number	Diff line change
`@@ -96,30 +96,30 @@ class Graph {`
`96`	`96`	`return raw_ptr;`
`97`	`97`	`}`
`98`	`98`
`99`		`- int getVertexValue(size_t layerID) const {`
	`99`	`+ [[nodiscard]] int getVertexValue(size_t layerID) const {`
`100`	`100`	`if (layerID >= arrayV_.size()) {`
`101`	`101`	`throw std::invalid_argument("ArrayV does not contain this ID.");`
`102`	`102`	`}`
`103`	`103`	`return arrayV_[layerID];`
`104`	`104`	`}`
`105`	`105`
`106`		`- int getEdgeValue(size_t pos) const {`
	`106`	`+ [[nodiscard]] int getEdgeValue(size_t pos) const {`
`107`	`107`	`if (pos >= arrayE_.size()) {`
`108`	`108`	`throw std::invalid_argument("ArrayE does not contain this.");`
`109`	`109`	`}`
`110`	`110`	`return arrayE_[pos];`
`111`	`111`	`}`
`112`	`112`
`113`		`- size_t getInputsSize(size_t layerID) const {`
	`113`	`+ [[nodiscard]] size_t getInputsSize(size_t layerID) const {`
`114`	`114`	`if (layerID >= in_edges_.size()) {`
`115`	`115`	`throw std::invalid_argument("Input edges array do not contain this ID.");`
`116`	`116`	`}`
`117`	`117`	`return in_edges_[layerID].size();`
`118`	`118`	`}`
`119`	`119`
`120`		`- int getLayersCount() const { return V_; }`
	`120`	`+ [[nodiscard]] int getLayersCount() const { return V_; }`
`121`	`121`
`122`		`- const Layer& getLayerFromID(size_t layerID) const {`
	`122`	`+ [[nodiscard]] const Layer& getLayerFromID(size_t layerID) const {`
`123`	`123`	`if (layerID >= layers_.size()) {`
`124`	`124`	`throw std::invalid_argument("Layers do not contain this ID.");`
`125`	`125`	`}`
`@@ -376,7 +376,7 @@ class Graph {`
`376`	`376`	`std::vector<Tensor> getWEIGHTS() { return weights_; }`
`377`	`377`	`#endif`
`378`	`378`
`379`		`- std::vector<std::pair<int, int>> getInOutDegrees() const {`
	`379`	`+ [[nodiscard]] std::vector<std::pair<int, int>> getInOutDegrees() const {`
`380`	`380`	`std::vector<int> in_degree(V_, 0);`
`381`	`381`
`382`	`382`	`for (int i = 0; i < V_; ++i) {`
`@@ -397,7 +397,7 @@ class Graph {`
`397`	`397`	`return result;`
`398`	`398`	`}`
`399`	`399`
`400`		`- std::vector<int> getTraversalOrder() const {`
	`400`	`+ [[nodiscard]] std::vector<int> getTraversalOrder() const {`
`401`	`401`	`auto in_out_degrees = getInOutDegrees();`
`402`	`402`	`std::vector<int> in_degree(V_);`
`403`	`403`	`for (int i = 0; i < V_; ++i) {`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ class FCLayerImpl : public LayerImpl<ValueType> {`
`84`	`84`	`}`
`85`	`85`	`weights_[i * this->inputShape_[0] + j] = value;`
`86`	`86`	`}`
`87`		`- ValueType get_weight(size_t i, size_t j) const {`
	`87`	`+ [[nodiscard]] ValueType get_weight(size_t i, size_t j) const {`
`88`	`88`	`if (i >= this->outputShape_[0] \|\| j >= this->inputShape_[0]) {`
`89`	`89`	`throw std::out_of_range("Invalid weight index");`
`90`	`90`	`}`
`@@ -96,7 +96,7 @@ class FCLayerImpl : public LayerImpl<ValueType> {`
`96`	`96`	`}`
`97`	`97`	`bias_[i] = value;`
`98`	`98`	`}`
`99`		`- ValueType get_bias(size_t i) const {`
	`99`	`+ [[nodiscard]] ValueType get_bias(size_t i) const {`
`100`	`100`	`if (i >= this->outputShape_[0]) {`
`101`	`101`	`throw std::out_of_range("Invalid bias index");`
`102`	`102`	`}`