Fix clang-tidy warnings (onnx#7392)

cyyever · web-flow · commit ff14dbc1f009 · 2025-10-15T08:06:16.000-07:00
### Description
&lt;!-- - Describe your changes. --&gt;
This PR fixes several clang-tidy warnings. Some readability rules were
not enabled due to a missing tailing comma, this PR fixes them. Two
C++20 rules are also disabled.
### Motivation and Context
Better code.
&lt;!-- - Why is this change required? What problem does it solve? --&gt;
&lt;!-- - If it fixes an open issue, please link to the issue here. --&gt;

Signed-off-by: Yuanyuan Chen &lt;cyyever@outlook.com&gt;
diff --git a/.clang-tidy b/.clang-tidy
@@ -30,14 +30,16 @@ Checks: >-
   -modernize-concat-nested-namespaces,
   -modernize-return-braced-init-list,
   -modernize-use-auto,
+  -modernize-use-integer-sign-comparison,
+  -modernize-use-ranges,
   -modernize-use-trailing-return-type,
   -modernize-use-nodiscard,
   readability-container-size-empty,
   readability-delete-null-pointer,
-  readability-duplicate-include
+  readability-duplicate-include,
   readability-misplaced-array-index,
   readability-non-const-parameter,
-  readability-redundant*
+  readability-redundant*,
   readability-simplify*,
   readability-static-accessed-through-instance,
   readability-static-definition-in-anonymous-namespace,
diff --git a/onnx/common/ir.h b/onnx/common/ir.h
@@ -839,7 +839,7 @@ class OpSetID final {
   explicit OpSetID(const OperatorSetIdProto& proto) : domain_(proto.domain()), version_(proto.version()) {}
 
   // Default Domain Constructor
-  explicit OpSetID(const int64_t version) : domain_(""), version_(version) {}
+  explicit OpSetID(const int64_t version) : version_(version) {}
 
   explicit OpSetID(std::string domain, int64_t version) : domain_(std::move(domain)), version_(version) {}
 
diff --git a/onnx/common/ir_pb_converter.cc b/onnx/common/ir_pb_converter.cc
@@ -112,7 +112,7 @@ static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {
   }
 
   for (int i = 0; i < tp.external_data_size(); i++) {
-    ret.external_data().push_back(std::make_pair(tp.external_data(i).key(), tp.external_data(i).value()));
+    ret.external_data().emplace_back(tp.external_data(i).key(), tp.external_data(i).value());
   }
   if (tp.has_data_location()) {
     ret.data_location() = tp.data_location();
diff --git a/onnx/defs/controlflow/old.cc b/onnx/defs/controlflow/old.cc
@@ -3222,8 +3222,6 @@ values are computed in the outer graph, they need to be passed in as extra state
 
 )DOC";
 
-extern void ScanInferenceFunction(InferenceContext& ctx);
-
 ONNX_OPERATOR_SET_SCHEMA(
     Scan,
     11,
diff --git a/onnx/defs/nn/defs.cc b/onnx/defs/nn/defs.cc
@@ -101,7 +101,7 @@ ONNX_API void convPoolShapeInference(
   }
 
   std::vector<int64_t> effective_kernel_shape = kernel_shape;
-  for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
     // accounting for dilation, how big is the kernel in this dimension
     effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
   }
@@ -427,8 +427,8 @@ static void maxUnpoolShapeInference(InferenceContext& ctx) {
       if (output_shape.dim_size() != 1) {
         fail_type_inference("'output_shape' must be rank 1 tensor.");
       }
-      if (output_shape.dim((int)0).has_dim_value() &&
-          static_cast<int>(output_shape.dim((int)0).dim_value()) != input_shape.dim_size()) {
+      if (output_shape.dim(0).has_dim_value() &&
+          static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {
         fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");
       }
     }
@@ -1158,7 +1158,7 @@ ONNX_API void convTransposeShapeInference(InferenceContext& ctx) {
   }
 
   std::vector<int64_t> effective_kernel_shape = kernel_shape;
-  for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
     // accounting for dilation, how big is the kernel in this dimension
     effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
   }
@@ -2359,7 +2359,6 @@ static void col2imShapeInference(InferenceContext& ctx) {
     }
     *final_image_shape->add_dim() = image_dim_i;
   }
-  return;
 }
 
 static const char* Col2Im_ver18_doc = R"DOC(
diff --git a/onnx/defs/nn/old.cc b/onnx/defs/nn/old.cc
@@ -179,7 +179,7 @@ static void convPoolShapeInference_opset19(
   }
 
   std::vector<int64_t> effective_kernel_shape = kernel_shape;
-  for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
     // accounting for dilation, how big is the kernel in this dimension
     effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
   }
@@ -193,8 +193,8 @@ static void convPoolShapeInference_opset19(
     pads.assign(n_input_dims * 2, 0);
     const auto* auto_pad_attr = ctx.getAttribute("auto_pad");
     if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {
-      int input_dims_size = static_cast<int>(n_input_dims);
-      for (int i = 0; i < input_dims_size; ++i) {
+      auto input_dims_size = n_input_dims;
+      for (size_t i = 0; i < input_dims_size; ++i) {
         int64_t residual = 0;
         int64_t stride = strides[i];
         if (stride > 1) {
@@ -206,7 +206,7 @@ static void convPoolShapeInference_opset19(
             residual -= stride;
           }
         }
-        if (i >= static_cast<int>(effective_kernel_shape.size())) {
+        if (i >= effective_kernel_shape.size()) {
           fail_shape_inference("kernel shape should have ", input_dims_size, " values in ", ctx.getDisplayName(), ".");
         }
         int64_t total_pad = residual == 0 ? effective_kernel_shape[i] - stride : effective_kernel_shape[i] - residual;
@@ -505,8 +505,8 @@ static void maxUnpoolShapeInference_opset11(InferenceContext& ctx) {
       if (output_shape.dim_size() != 1) {
         fail_type_inference("'output_shape' must be rank 1 tensor.");
       }
-      if (output_shape.dim(static_cast<int>(0)).has_dim_value() &&
-          static_cast<int>(output_shape.dim(static_cast<int>(0)).dim_value()) != input_shape.dim_size()) {
+      if (output_shape.dim(0).has_dim_value() &&
+          static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {
         fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");
       }
     }
@@ -670,7 +670,7 @@ static void convTransposeShapeInference_opset11(InferenceContext& ctx) {
   }
 
   std::vector<int64_t> effective_kernel_shape = kernel_shape;
-  for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
     // accounting for dilation, how big is the kernel in this dimension
     effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
   }
@@ -2005,7 +2005,7 @@ static void convPoolShapeInference1(
   }
 
   std::vector<int64_t> effective_kernel_shape = kernel_shape;
-  for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
     // accounting for dilation, how big is the kernel in this dimension
     effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
   }
@@ -2606,8 +2606,8 @@ static void maxUnpoolShapeInference1(InferenceContext& ctx) {
       if (output_shape.dim_size() != 1) {
         fail_type_inference("'output_shape' must be rank 1 tensor.");
       }
-      if (output_shape.dim(static_cast<int>(0)).has_dim_value() &&
-          static_cast<int>(output_shape.dim(static_cast<int>(0)).dim_value()) != input_shape.dim_size()) {
+      if (output_shape.dim(0).has_dim_value() &&
+          static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {
         fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");
       }
     }
@@ -3016,7 +3016,7 @@ static void convTransposeShapeInference1(InferenceContext& ctx) {
   }
 
   std::vector<int64_t> effective_kernel_shape = kernel_shape;
-  for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {
+  for (size_t i = 0; i < kernel_shape.size(); i++) {
     // accounting for dilation, how big is the kernel in this dimension
     effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;
   }
diff --git a/onnx/defs/parser.cc b/onnx/defs/parser.cc
@@ -569,7 +569,7 @@ Status OnnxParser::ParseSingleAttributeValue(AttributeProto& attr, AttributeProt
         Literal literal;
         PARSE_TOKEN(literal);
         attr.set_type(AttributeProto_AttributeType_FLOAT);
-        attr.set_f(static_cast<float>(std::stof(literal.value)));
+        attr.set_f(std::stof(literal.value));
       } else {
         attr.set_type(AttributeProto_AttributeType_GRAPH);
         PARSE(*attr.mutable_g());
@@ -591,7 +591,7 @@ Status OnnxParser::ParseSingleAttributeValue(AttributeProto& attr, AttributeProt
         break;
       case LiteralType::FLOAT_LITERAL:
         attr.set_type(AttributeProto_AttributeType_FLOAT);
-        attr.set_f(static_cast<float>(std::stof(literal.value)));
+        attr.set_f(std::stof(literal.value));
         break;
       case LiteralType::STRING_LITERAL:
         attr.set_type(AttributeProto_AttributeType_STRING);
diff --git a/onnx/defs/printer.cc b/onnx/defs/printer.cc
@@ -89,7 +89,7 @@ class ProtoPrinter {
   }
 
   template <typename T>
-  inline void print(const T& prim) {
+  void print(const T& prim) {
     output_ << prim;
   }
 
@@ -104,21 +104,21 @@ class ProtoPrinter {
   }
 
   template <typename T>
-  inline void printKeyValuePair(KeyWordMap::KeyWord key, const T& val, bool addsep = true) {
+  void printKeyValuePair(KeyWordMap::KeyWord key, const T& val, bool addsep = true) {
     if (addsep)
       output_ << "," << '\n';
     output_ << std::setw(indent_level) << ' ' << KeyWordMap::ToString(key) << ": ";
     print(val);
   }
 
-  inline void printKeyValuePair(KeyWordMap::KeyWord key, const std::string& val) {
+  void printKeyValuePair(KeyWordMap::KeyWord key, const std::string& val) {
     output_ << "," << '\n';
     output_ << std::setw(indent_level) << ' ' << KeyWordMap::ToString(key) << ": ";
     printQuoted(val);
   }
 
   template <typename Collection>
-  inline void printSet(const char* open, const char* separator, const char* close, const Collection& coll) {
+  void printSet(const char* open, const char* separator, const char* close, const Collection& coll) {
     const char* sep = "";
     output_ << open;
     for (auto& elt : coll) {
@@ -130,7 +130,7 @@ class ProtoPrinter {
   }
 
   template <typename Collection>
-  inline void printIdSet(const char* open, const char* separator, const char* close, const Collection& coll) {
+  void printIdSet(const char* open, const char* separator, const char* close, const Collection& coll) {
     const char* sep = "";
     output_ << open;
     for (auto& elt : coll) {
diff --git a/onnx/defs/schema.cc b/onnx/defs/schema.cc
@@ -28,8 +28,6 @@ namespace ONNX_NAMESPACE {
 // Other positive integer means the ONNX schemas for the specified version have been loaded
 int OpSchemaRegistry::loaded_schema_version = -1;
 
-constexpr int OpSchema::kUninitializedSinceVersion;
-
 // By default if opset_version_to_load=0, it registers all opset schema for all opset versions
 // Otherwise, it only registers the latest schema according to opset_version_to_load
 void RegisterSchema(
diff --git a/onnx/defs/schema.h b/onnx/defs/schema.h
@@ -427,11 +427,7 @@ class OpSchema final {
 
   struct Attribute final {
     Attribute(std::string name_, std::string description_, AttributeProto::AttributeType type_, bool required_)
-        : name(std::move(name_)),
-          description(std::move(description_)),
-          type(type_),
-          required(required_),
-          default_value() {}
+        : name(std::move(name_)), description(std::move(description_)), type(type_), required(required_) {}
 
     Attribute(std::string name_, std::string description_, AttributeProto default_value_)
         : name(std::move(name_)),
@@ -729,11 +725,11 @@ class OpSchema final {
   }
 
   ONNX_API bool has_type_and_shape_inference_function() const {
-    return tensor_inference_function_ ? true : false;
+    return static_cast<bool>(tensor_inference_function_);
   }
 
   ONNX_API bool has_data_propagation_function() const {
-    return data_propagation_function_ ? true : false;
+    return static_cast<bool>(data_propagation_function_);
   }
 
   ONNX_API std::vector<int> function_opset_versions() const {
@@ -852,7 +848,7 @@ class OpSchema final {
   std::string doc_;
   // Default domain value ("") means it's ONNX domain.
   std::string domain_ = ONNX_DOMAIN;
-  std::unordered_map<std::string, Attribute> attributes_{};
+  std::unordered_map<std::string, Attribute> attributes_;
   bool allows_unchecked_attributes_ = false;
   std::vector<FormalParameter> inputs_;
   std::vector<FormalParameter> outputs_;
@@ -1091,7 +1087,7 @@ class OpSchemaRegistry final : public ISchemaRegistry {
       }
       auto lower_bound_incl = ver_range_it->second.first;
       auto upper_bound_incl = ver_range_it->second.second;
-      if (!(lower_bound_incl <= ver && upper_bound_incl >= ver)) {
+      if (lower_bound_incl > ver || upper_bound_incl < ver) {
         std::stringstream err;
         err << "Trying to register schema with name " << op_name << " (domain: " << op_domain << " version: " << ver
             << ") from file " << op_schema.file() << " line " << op_schema.line() << ", but its version is not "
@@ -1349,9 +1345,6 @@ size_t ReplaceAll(std::string& s, const char* from, const char* to);
   static ONNX_NAMESPACE::OpSchemaRegistry::OpSchemaRegisterOnce(op_schema_register_once##name##Counter) ONNX_UNUSED = \
       OpSchema(#name, __FILE__, __LINE__)
 
-// Helper function
-size_t ReplaceAll(std::string& s, const char* from, const char* to);
-
 ONNX_API inline std::string GenerateOptionalArgumentsDoc() {
   return "This operator has **optional** inputs/outputs. "
          "See [the doc](IR.md) for more details about the representation of "
diff --git a/onnx/defs/shape_inference.h b/onnx/defs/shape_inference.h
@@ -326,7 +326,7 @@ inline bool hasShape(const TypeProto& type) {
 
 template <typename Context>
 inline bool hasInputShape(const Context& ctx, size_t n) {
-  return ctx.getNumInputs() > static_cast<size_t>(n) && ctx.getInputType(n) && hasShape(*ctx.getInputType(n));
+  return ctx.getNumInputs() > n && ctx.getInputType(n) && hasShape(*ctx.getInputType(n));
 }
 
 template <typename Context>
diff --git a/onnx/defs/tensor/defs.cc b/onnx/defs/tensor/defs.cc
@@ -682,7 +682,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             false)
         .SetDoc(Split_ver18_doc)
         .TypeAndShapeInferenceFunction([](InferenceContext& ctx) {
-          for (int i = 0; i < static_cast<int>(ctx.getNumOutputs()); ++i) {
+          for (size_t i = 0; i < ctx.getNumOutputs(); ++i) {
             propagateElemTypeFromInputToOutput(ctx, 0, i);
           }
           if (!hasNInputShapes(ctx, 1)) {
@@ -928,7 +928,7 @@ ONNX_OPERATOR_SET_SCHEMA(
               (hasInputShape(ctx, 4) && !ctx.getInputData(4))) {
             const auto input_rank = ctx.getInputType(0)->tensor_type().shape().dim_size();
             // we can infer the output rank - it never changes
-            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
+            for (int i = 0; i < input_rank; ++i) {
               ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
             }
             return;
@@ -984,7 +984,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             }
           }
 
-          for (size_t i = 0; (int64_t)i < input_rank; ++i) {
+          for (int i = 0; i < input_rank; ++i) {
             // first update rank of output dim
             auto* output_dim = ctx.getOutputType(0)->mutable_tensor_type()->mutable_shape()->add_dim();
             const auto& input_dim = input_shape.dim((int)i);
@@ -2126,7 +2126,7 @@ ONNX_OPERATOR_SET_SCHEMA(
                   "to the number of input dimensions.");
             }
 
-            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
+            for (int i = 0; i < input_rank; ++i) {
               const auto& input_dim = input_shape.dim((int)i);
               auto* output_dim = output_shape->add_dim();
               if (input_dim.has_dim_value()) {
@@ -2137,7 +2137,7 @@ ONNX_OPERATOR_SET_SCHEMA(
             // Infer output shape's rank in any case (if repeats data is not
             // available)
             auto* output_shape_0 = getOutputShape(ctx, 0);
-            for (size_t i = 0; (int64_t)i < input_rank; ++i) {
+            for (int i = 0; i < input_rank; ++i) {
               output_shape_0->add_dim();
             }
           }
diff --git a/onnx/defs/tensor/old.cc b/onnx/defs/tensor/old.cc
diff --git a/onnx/defs/tensor/utils.cc b/onnx/defs/tensor/utils.cc
diff --git a/onnx/inliner/inliner.cc b/onnx/inliner/inliner.cc
diff --git a/onnx/shape_inference/implementation.h b/onnx/shape_inference/implementation.h
diff --git a/onnx/version_converter/adapters/axis_input_to_attribute.h b/onnx/version_converter/adapters/axis_input_to_attribute.h
diff --git a/onnx/version_converter/helper.cc b/onnx/version_converter/helper.cc

Original file line number	Diff line number	Diff line change
`@@ -112,7 +112,7 @@ static Tensor tensorProtoToTensor(const ONNX_NAMESPACE::TensorProto& tp) {`
`112`	`112`	`}`
`113`	`113`
`114`	`114`	`for (int i = 0; i < tp.external_data_size(); i++) {`
`115`		`- ret.external_data().push_back(std::make_pair(tp.external_data(i).key(), tp.external_data(i).value()));`
	`115`	`+ ret.external_data().emplace_back(tp.external_data(i).key(), tp.external_data(i).value());`
`116`	`116`	`}`
`117`	`117`	`if (tp.has_data_location()) {`
`118`	`118`	`ret.data_location() = tp.data_location();`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ ONNX_API void convPoolShapeInference(`
`101`	`101`	`}`
`102`	`102`
`103`	`103`	`std::vector<int64_t> effective_kernel_shape = kernel_shape;`
`104`		`- for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {`
	`104`	`+ for (size_t i = 0; i < kernel_shape.size(); i++) {`
`105`	`105`	`// accounting for dilation, how big is the kernel in this dimension`
`106`	`106`	`effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;`
`107`	`107`	`}`
`@@ -427,8 +427,8 @@ static void maxUnpoolShapeInference(InferenceContext& ctx) {`
`427`	`427`	`if (output_shape.dim_size() != 1) {`
`428`	`428`	`fail_type_inference("'output_shape' must be rank 1 tensor.");`
`429`	`429`	`}`
`430`		`- if (output_shape.dim((int)0).has_dim_value() &&`
`431`		`- static_cast<int>(output_shape.dim((int)0).dim_value()) != input_shape.dim_size()) {`
	`430`	`+ if (output_shape.dim(0).has_dim_value() &&`
	`431`	`+ static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {`
`432`	`432`	`fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");`
`433`	`433`	`}`
`434`	`434`	`}`
`@@ -1158,7 +1158,7 @@ ONNX_API void convTransposeShapeInference(InferenceContext& ctx) {`
`1158`	`1158`	`}`
`1159`	`1159`
`1160`	`1160`	`std::vector<int64_t> effective_kernel_shape = kernel_shape;`
`1161`		`- for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {`
	`1161`	`+ for (size_t i = 0; i < kernel_shape.size(); i++) {`
`1162`	`1162`	`// accounting for dilation, how big is the kernel in this dimension`
`1163`	`1163`	`effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;`
`1164`	`1164`	`}`
`@@ -2359,7 +2359,6 @@ static void col2imShapeInference(InferenceContext& ctx) {`
`2359`	`2359`	`}`
`2360`	`2360`	`*final_image_shape->add_dim() = image_dim_i;`
`2361`	`2361`	`}`
`2362`		`- return;`
`2363`	`2362`	`}`
`2364`	`2363`
`2365`	`2364`	`static const char* Col2Im_ver18_doc = R"DOC(`
Original file line number	Diff line number	Diff line change
`@@ -179,7 +179,7 @@ static void convPoolShapeInference_opset19(`
`179`	`179`	`}`
`180`	`180`
`181`	`181`	`std::vector<int64_t> effective_kernel_shape = kernel_shape;`
`182`		`- for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {`
	`182`	`+ for (size_t i = 0; i < kernel_shape.size(); i++) {`
`183`	`183`	`// accounting for dilation, how big is the kernel in this dimension`
`184`	`184`	`effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;`
`185`	`185`	`}`
`@@ -193,8 +193,8 @@ static void convPoolShapeInference_opset19(`
`193`	`193`	`pads.assign(n_input_dims * 2, 0);`
`194`	`194`	`const auto* auto_pad_attr = ctx.getAttribute("auto_pad");`
`195`	`195`	`if ((nullptr != auto_pad_attr) && (auto_pad_attr->s() != "VALID")) {`
`196`		`- int input_dims_size = static_cast<int>(n_input_dims);`
`197`		`- for (int i = 0; i < input_dims_size; ++i) {`
	`196`	`+ auto input_dims_size = n_input_dims;`
	`197`	`+ for (size_t i = 0; i < input_dims_size; ++i) {`
`198`	`198`	`int64_t residual = 0;`
`199`	`199`	`int64_t stride = strides[i];`
`200`	`200`	`if (stride > 1) {`
`@@ -206,7 +206,7 @@ static void convPoolShapeInference_opset19(`
`206`	`206`	`residual -= stride;`
`207`	`207`	`}`
`208`	`208`	`}`
`209`		`- if (i >= static_cast<int>(effective_kernel_shape.size())) {`
	`209`	`+ if (i >= effective_kernel_shape.size()) {`
`210`	`210`	`fail_shape_inference("kernel shape should have ", input_dims_size, " values in ", ctx.getDisplayName(), ".");`
`211`	`211`	`}`
`212`	`212`	`int64_t total_pad = residual == 0 ? effective_kernel_shape[i] - stride : effective_kernel_shape[i] - residual;`
`@@ -505,8 +505,8 @@ static void maxUnpoolShapeInference_opset11(InferenceContext& ctx) {`
`505`	`505`	`if (output_shape.dim_size() != 1) {`
`506`	`506`	`fail_type_inference("'output_shape' must be rank 1 tensor.");`
`507`	`507`	`}`
`508`		`- if (output_shape.dim(static_cast<int>(0)).has_dim_value() &&`
`509`		`- static_cast<int>(output_shape.dim(static_cast<int>(0)).dim_value()) != input_shape.dim_size()) {`
	`508`	`+ if (output_shape.dim(0).has_dim_value() &&`
	`509`	`+ static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {`
`510`	`510`	`fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");`
`511`	`511`	`}`
`512`	`512`	`}`
`@@ -670,7 +670,7 @@ static void convTransposeShapeInference_opset11(InferenceContext& ctx) {`
`670`	`670`	`}`
`671`	`671`
`672`	`672`	`std::vector<int64_t> effective_kernel_shape = kernel_shape;`
`673`		`- for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {`
	`673`	`+ for (size_t i = 0; i < kernel_shape.size(); i++) {`
`674`	`674`	`// accounting for dilation, how big is the kernel in this dimension`
`675`	`675`	`effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;`
`676`	`676`	`}`
`@@ -2005,7 +2005,7 @@ static void convPoolShapeInference1(`
`2005`	`2005`	`}`
`2006`	`2006`
`2007`	`2007`	`std::vector<int64_t> effective_kernel_shape = kernel_shape;`
`2008`		`- for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {`
	`2008`	`+ for (size_t i = 0; i < kernel_shape.size(); i++) {`
`2009`	`2009`	`// accounting for dilation, how big is the kernel in this dimension`
`2010`	`2010`	`effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;`
`2011`	`2011`	`}`
`@@ -2606,8 +2606,8 @@ static void maxUnpoolShapeInference1(InferenceContext& ctx) {`
`2606`	`2606`	`if (output_shape.dim_size() != 1) {`
`2607`	`2607`	`fail_type_inference("'output_shape' must be rank 1 tensor.");`
`2608`	`2608`	`}`
`2609`		`- if (output_shape.dim(static_cast<int>(0)).has_dim_value() &&`
`2610`		`- static_cast<int>(output_shape.dim(static_cast<int>(0)).dim_value()) != input_shape.dim_size()) {`
	`2609`	`+ if (output_shape.dim(0).has_dim_value() &&`
	`2610`	`+ static_cast<int>(output_shape.dim(0).dim_value()) != input_shape.dim_size()) {`
`2611`	`2611`	`fail_shape_inference("'output_shape' must have same number of elements as the shape of input tensor X.");`
`2612`	`2612`	`}`
`2613`	`2613`	`}`
`@@ -3016,7 +3016,7 @@ static void convTransposeShapeInference1(InferenceContext& ctx) {`
`3016`	`3016`	`}`
`3017`	`3017`
`3018`	`3018`	`std::vector<int64_t> effective_kernel_shape = kernel_shape;`
`3019`		`- for (int i = 0; i < static_cast<int>(kernel_shape.size()); i++) {`
	`3019`	`+ for (size_t i = 0; i < kernel_shape.size(); i++) {`
`3020`	`3020`	`// accounting for dilation, how big is the kernel in this dimension`
`3021`	`3021`	`effective_kernel_shape[i] = (effective_kernel_shape[i] - 1) * dilations[i] + 1;`
`3022`	`3022`	`}`