Fix lint C++ actions (microsoft#21303)

### Description
<!-- Describe your changes. -->


microsoft@83e0c6b
is the last commit having Lint C++ actions pass.


![image](https://github.com/microsoft/onnxruntime/assets/10530022/96bf005e-5815-46d0-ac17-c6094200957c)



microsoft@4a7eaff
is the first commit let it fail.


![image](https://github.com/microsoft/onnxruntime/assets/10530022/72a9271e-7b4b-40f8-83a5-f28b82c5e726)



Reviewdog/action-cpplint@master changed since that day.
https://github.com/reviewdog/action-cpplint/pull/42/files make
action-cpplint starts using reviewdog release
https://github.com/reviewdog/reviewdog/releases/tag/v0.19.0.


Optional Lint also failed with many typos, should be also related to the
same reason. Let's fix that in different prs.

### Motivation and Context
<!-- - Why is this change required? What problem does it solve?
- If it fixes an open issue, please link to the issue here. -->

Author: pengwa

.github/workflows/lint.yml

@@ -98,6 +98,13 @@ jobs:
             --exclude=onnxruntime/core/mlas/inc/*
             --exclude=onnxruntime/core/mlas/lib/*
             --exclude=onnxruntime/contrib_ops/cuda/bert/flash_attention/*
+            --exclude=build/Debug/*
+            --exclude=cmake/*
+            --exclude=csharp/test/*
+            --exclude=onnxruntime/core/providers/dml/DmlExecutionProvider/src/Operators/GeneratedShaders/*
+            --exclude=orttraining/orttraining/test/*
+            --exclude=onnxruntime/test/*
+            --exclude=winml/*
           filter: "-runtime/references"
 
   lint-js:

include/onnxruntime/core/providers/cuda/cuda_context.h

@@ -12,14 +12,16 @@
 
 #define ORT_CUDA_CTX
 
-#include "cuda_resource.h"
-#include "core/providers/custom_op_context.h"
 #include <cuda.h>
 #include <cuda_runtime.h>
 #ifndef USE_CUDA_MINIMAL
 #include <cublas_v2.h>
 #include <cudnn.h>
 #endif
+
+#include "core/providers/cuda/cuda_resource.h"
+#include "core/providers/custom_op_context.h"
+
 namespace Ort {
 
 namespace Custom {

onnxruntime/core/graph/graph.cc

@@ -2,12 +2,14 @@
 // Licensed under the MIT License.
 
 #include "core/graph/graph_utils.h"
-
-#include <queue>
-
 #include "core/graph/graph.h"
 #include "core/common/logging/logging.h"
 
+#include <algorithm>
+#include <queue>
+#include <string>
+#include <vector>
+
 namespace onnxruntime {
 
 namespace graph_utils {
@@ -56,7 +58,8 @@ static bool CanUpdateImplicitInputNameInSubgraph(const Node& node,
     }
 
     for (auto& subgraph_node : subgraph->Nodes()) {
-      // recurse if this node also consumes removed_output_name as an implicit input (i.e. there are multiple levels of nested
+      // recurse if this node also consumes removed_output_name as an implicit input (i.e. there are multiple levels
+      // of nested
       // subgraphs, and at least one level lower uses removed_output_name as an implicit input
       const auto subgraph_node_implicit_inputs = subgraph_node.ImplicitInputDefs();
       if (!subgraph_node_implicit_inputs.empty()) {
@@ -464,13 +467,13 @@ static bool IsOnlyOneOutputUsed(const Graph& graph, const Node& node, const std:
   // a) there's only 1, and b) it's the same as any output consumed by another node
   auto output_indexes = graph.GetNodeOutputsInGraphOutputs(node);
   auto num_graph_outputs = output_indexes.size();
-  if (num_graph_outputs > 1)
+  if (num_graph_outputs > 1) {
     return false;
-  else if (num_graph_outputs == 1) {
-    if (first_output != unassigned)
+  } else if (num_graph_outputs == 1) {
+    if (first_output != unassigned) {
       // an output is consumed by other nodes, so make sure the same output is providing the graph output
       return output_indexes.front() == first_output;
-    else {
+    } else {
       // graph output only as no other nodes are consuming the output, so just update the output_name
       output_name = &node.OutputDefs()[output_indexes.front()]->Name();
     }
@@ -678,7 +681,8 @@ const Node* FirstParentByType(const Node& node, const std::string& parent_type)
   return nullptr;
 }
 
-void ReplaceDownstreamNodeInput(Graph& graph, Node& node, int output_idx, Node& replacement, int replacement_output_idx) {
+void ReplaceDownstreamNodeInput(Graph& graph, Node& node, int output_idx, Node& replacement,
+                                int replacement_output_idx) {
   // get the output edges from node for output_idx
   std::vector<GraphEdge> output_edges = GraphEdge::GetNodeOutputEdges(node, output_idx);
 
@@ -726,7 +730,9 @@ void AddNodeInput(Node& target, int target_input_idx, NodeArg& new_input) {
               "Can only add a new input at the end of the current ones.");
 
   target.MutableInputDefs().push_back(&new_input);
-  assert(target.MutableInputArgsCount().size() > static_cast<size_t>(target_input_idx));  // expect existing entry for all possible inputs
+
+  // expect existing entry for all possible inputs
+  assert(target.MutableInputArgsCount().size() > static_cast<size_t>(target_input_idx));
   target.MutableInputArgsCount()[target_input_idx] = 1;
 }
 
@@ -798,7 +804,8 @@ bool FindPath(const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMat
         // For output edge, there could be multiple edges matched.
         // This function will return failure in such case by design.
         if (nullptr != edge_found) {
-          LOGS(logger, WARNING) << "Failed since multiple edges matched:" << current_node->OpType() << "->" << edge.op_type;
+          LOGS(logger, WARNING) << "Failed since multiple edges matched:" << current_node->OpType() << "->"
+                                << edge.op_type;
           return false;
         }
         edge_found = &(*it);
@@ -821,7 +828,8 @@ bool FindPath(const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMat
   return true;
 }
 
-bool FindPath(Graph& graph, const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMatch> edges_to_match, std::vector<std::reference_wrapper<Node>>& result, const logging::Logger& logger) {
+bool FindPath(Graph& graph, const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMatch> edges_to_match,
+              std::vector<std::reference_wrapper<Node>>& result, const logging::Logger& logger) {
   result.clear();
 
   std::vector<const Node::EdgeEnd*> edge_ends;
@@ -830,9 +838,10 @@ bool FindPath(Graph& graph, const Node& node, bool is_input_edge, gsl::span<cons
   }
 
   result.reserve(edges_to_match.size());
-  std::transform(edge_ends.begin(), edge_ends.end(), std::back_inserter(result), [&graph](const Node::EdgeEnd* edge_end) -> Node& {
-    return *graph.GetNode(edge_end->GetNode().Index());
-  });
+  std::transform(edge_ends.begin(), edge_ends.end(), std::back_inserter(result),
+                 [&graph](const Node::EdgeEnd* edge_end) -> Node& {
+                   return *graph.GetNode(edge_end->GetNode().Index());
+                 });
 
   return true;
 }

onnxruntime/core/graph/graph_utils.cc

@@ -8,6 +8,9 @@
 #include "core/graph/onnx_protobuf.h"
 #include "core/graph/graph.h"
 
+#include <string>
+#include <vector>
+
 namespace onnxruntime {
 namespace graph_utils {
 
@@ -247,7 +250,8 @@ e.g. Node A produces outputs A1 and A2.
      to replace B1 (output index 0 for node B) with A2 (output index 1 for node A) as input to the downstream node C.
      The edge that existed between B and C for B1 will be removed, and replaced with an edge between A and C for A2.
 */
-void ReplaceDownstreamNodeInput(Graph& graph, Node& node, int output_idx, Node& replacement, int replacement_output_idx);
+void ReplaceDownstreamNodeInput(Graph& graph, Node& node, int output_idx, Node& replacement,
+                                int replacement_output_idx);
 
 /** Replace the input to a node with a NodeArg.
 @remarks The replacement only updates the node's input definition and does not create any edges,
@@ -302,11 +306,13 @@ inline void FinalizeNodeFusion(Graph& graph,
     The output definitions and edges from the last node in 'nodes' will be moved to replacement_node.
     All nodes in 'nodes' will be removed.
 */
-inline void FinalizeNodeFusion(Graph& graph, gsl::span<const std::reference_wrapper<Node>> nodes, Node& replacement_node) {
+inline void FinalizeNodeFusion(Graph& graph, gsl::span<const std::reference_wrapper<Node>> nodes,
+                               Node& replacement_node) {
   FinalizeNodeFusion(graph, nodes, replacement_node, replacement_node);
 }
 
-inline void FinalizeNodeFusion(Graph& graph, std::initializer_list<std::reference_wrapper<Node>> nodes, Node& replacement_node) {
+inline void FinalizeNodeFusion(Graph& graph, std::initializer_list<std::reference_wrapper<Node>> nodes,
+                               Node& replacement_node) {
   FinalizeNodeFusion(graph, AsSpan(nodes), replacement_node, replacement_node);
 }
 
@@ -357,17 +363,23 @@ struct EdgeEndToMatch {
     It is recommended to match path from bottom to top direction to avoid such issue.
     It is because each node input (dst_arg_index) only accepts one input edge.
 */
-bool FindPath(const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMatch> edges_to_match, std::vector<const Node::EdgeEnd*>& result, const logging::Logger& logger);
+bool FindPath(const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMatch> edges_to_match,
+              std::vector<const Node::EdgeEnd*>& result, const logging::Logger& logger);
 
-inline bool FindPath(const Node& node, bool is_input_edge, std::initializer_list<EdgeEndToMatch> edges_to_match, std::vector<const Node::EdgeEnd*>& result, const logging::Logger& logger) {
+inline bool FindPath(const Node& node, bool is_input_edge, std::initializer_list<EdgeEndToMatch> edges_to_match,
+                     std::vector<const Node::EdgeEnd*>& result, const logging::Logger& logger) {
   return FindPath(node, is_input_edge, AsSpan(edges_to_match), result, logger);
 }
 
 /** Same as FindPath above, but return the references of matched Node
  */
-bool FindPath(Graph& graph, const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMatch> edges_to_match, std::vector<std::reference_wrapper<Node>>& result, const logging::Logger& logger);
+bool FindPath(Graph& graph, const Node& node, bool is_input_edge, gsl::span<const EdgeEndToMatch> edges_to_match,
+              std::vector<std::reference_wrapper<Node>>& result, const logging::Logger& logger);
 
-inline bool FindPath(Graph& graph, const Node& node, bool is_input_edge, std::initializer_list<EdgeEndToMatch> edges_to_match, std::vector<std::reference_wrapper<Node>>& result, const logging::Logger& logger) {
+inline bool FindPath(Graph& graph, const Node& node, bool is_input_edge,
+                     std::initializer_list<EdgeEndToMatch> edges_to_match,
+                     std::vector<std::reference_wrapper<Node>>& result,
+                     const logging::Logger& logger) {
   return FindPath(graph, node, is_input_edge, AsSpan(edges_to_match), result, logger);
 }
 

onnxruntime/core/graph/graph_utils.h

@@ -332,7 +332,7 @@ const std::vector<NodeIndex>& GraphViewer::GetNodesInTopologicalOrder(ExecutionO
 }
 
 const std::vector<NodeIndex>& GraphViewer::GetRootNodes() const {
-  // TODO: See if we need to calculate the root_nodes_ of the filtered graph.
+  // TODO(somebody): See if we need to calculate the root_nodes_ of the filtered graph.
   // GetRootNodes is only used by parallel executor currently, and isn't relevant to the usage of a filtered graph.
   ORT_ENFORCE(filter_info_ == nullptr, "Not supported with filtered graph.");
 

onnxruntime/core/graph/graph_viewer.cc

@@ -140,12 +140,13 @@ Model::Model(const std::string& graph_name,
     auto func_template_ptr = std::make_unique<FunctionTemplate>();
     func_template_ptr->op_schema_ = std::move(func_schema_ptr);
     func_template_ptr->onnx_func_proto_ = &func;
-    model_local_function_templates_maps_.insert_or_assign(function_utils::GetFunctionIdentifier(func.domain(), func.name()),
+    model_local_function_templates_maps_.insert_or_assign(function_utils::GetFunctionIdentifier(func.domain(),
+                                                                                                func.name()),
                                                           std::move(func_template_ptr));
   }
 
   // need to call private ctor so can't use make_shared
-  GSL_SUPPRESS(r.11)
+  GSL_SUPPRESS(r .11)
   graph_.reset(new Graph(*this, model_proto_.mutable_graph(), *p_domain_to_version, IrVersion(), schema_registry,
                          logger, options.strict_shape_type_inference));
 }
@@ -269,11 +270,13 @@ Model::Model(ModelProto&& model_proto, const PathString& model_path,
     auto func_template_ptr = std::make_unique<FunctionTemplate>();
     func_template_ptr->op_schema_ = std::move(func_schema_ptr);
     func_template_ptr->onnx_func_proto_ = &func;
-    model_local_function_templates_maps_.insert_or_assign(function_utils::GetFunctionIdentifier(func.domain(), func.name()), std::move(func_template_ptr));
+    model_local_function_templates_maps_.insert_or_assign(function_utils::GetFunctionIdentifier(func.domain(),
+                                                                                                func.name()),
+                                                          std::move(func_template_ptr));
   }
 
   // create instance. need to call private ctor so can't use make_unique
-  GSL_SUPPRESS(r.11)
+  GSL_SUPPRESS(r .11)
   graph_.reset(new Graph(*this, model_proto_.mutable_graph(), domain_to_version, IrVersion(), schema_registry,
                          logger, options.strict_shape_type_inference));
 }
@@ -425,7 +428,7 @@ Status Model::Load(const ModelProto& model_proto,
   }
 
   // need to call private ctor so can't use make_shared
-  GSL_SUPPRESS(r.11)
+  GSL_SUPPRESS(r .11)
 
   auto status = Status::OK();
   ORT_TRY {
@@ -465,7 +468,7 @@ Status Model::Load(ModelProto&& model_proto,
   }
 
   // need to call private ctor so can't use make_shared
-  GSL_SUPPRESS(r.11)
+  GSL_SUPPRESS(r .11)
   auto status = Status::OK();
   ORT_TRY {
     model = std::make_unique<Model>(std::move(model_proto), model_path, local_registries, logger, options);
@@ -512,7 +515,7 @@ static Status LoadModelHelper(const T& file_path, Loader loader) {
   }
 
   if (!status.IsOK()) {
-    GSL_SUPPRESS(es.84)
+    GSL_SUPPRESS(es .84)
     ORT_IGNORE_RETURN_VALUE(Env::Default().FileClose(fd));
     return status;
   }
@@ -554,7 +557,8 @@ static Status SaveModel(Model& model, const T& file_path) {
            const file_path = UTF8ToString($2);
            const bytes = new Uint8Array(buffer_size);
            bytes.set(HEAPU8.subarray(buffer, buffer + buffer_size));
-           if (typeof process == 'object' && typeof process.versions == 'object' && typeof process.versions.node == 'string') {
+           if (typeof process == 'object' && typeof process.versions == 'object' &&
+               typeof process.versions.node == 'string') {
              // Node.js
              require('fs').writeFileSync(file_path, bytes);
            } else {
@@ -585,7 +589,7 @@ static Status SaveModel(Model& model, const T& file_path) {
     });
   }
   if (!status.IsOK()) {
-    GSL_SUPPRESS(es.84)
+    GSL_SUPPRESS(es .84)
     ORT_IGNORE_RETURN_VALUE(Env::Default().FileClose(fd));
     return status;
   }
@@ -616,7 +620,7 @@ static Status SaveModelWithExternalInitializers(Model& model,
     });
   }
   if (!status.IsOK()) {
-    GSL_SUPPRESS(es.84)
+    GSL_SUPPRESS(es .84)
     ORT_IGNORE_RETURN_VALUE(Env::Default().FileClose(fd));
     return status;
   }
@@ -628,8 +632,8 @@ Status Model::Load(const PathString& file_path,
   return LoadModel(file_path, model_proto);
 }
 
-GSL_SUPPRESS(r.30)  // spurious warnings. p_model is potentially reset in the internal call to Load
-GSL_SUPPRESS(r.35)
+GSL_SUPPRESS(r .30)  // spurious warnings. p_model is potentially reset in the internal call to Load
+GSL_SUPPRESS(r .35)
 Status Model::Load(const PathString& file_path, std::shared_ptr<Model>& p_model,
                    const IOnnxRuntimeOpSchemaRegistryList* local_registries,
                    const logging::Logger& logger, const ModelOptions& options) {
@@ -762,7 +766,8 @@ Status Model::SaveWithExternalInitializers(Model& model,
 
   ORT_RETURN_IF_ERROR(model.MainGraph().Resolve());
 
-  auto model_proto = model.ToGraphProtoWithExternalInitializers(external_file_name, file_path, initializer_size_threshold);
+  auto model_proto = model.ToGraphProtoWithExternalInitializers(external_file_name, file_path,
+                                                                initializer_size_threshold);
   google::protobuf::io::FileOutputStream output(fd);
   const bool result = model_proto.SerializeToZeroCopyStream(&output) && output.Flush();
   if (result) {

onnxruntime/core/graph/model.cc

@@ -3,12 +3,13 @@
 
 #pragma once
 
-#include <functional>
-#include <unordered_map>
 #include "core/graph/onnx_protobuf.h"
 #include "core/common/status.h"
 #include "core/graph/constants.h"
 
+#include <functional>
+#include <unordered_map>
+
 namespace onnxruntime {
 using AttrType = ONNX_NAMESPACE::AttributeProto_AttributeType;
 using NodeAttributes = std::unordered_map<std::string, ONNX_NAMESPACE::AttributeProto>;
@@ -29,19 +30,18 @@ AttributeProto_AttributeType_GRAPHS = 10,
 AttributeProto_AttributeType_SPARSE_TENSOR = 22,
 AttributeProto_AttributeType_SPARSE_TENSORS = 23,
 */
-static constexpr const char* kAttrTypeStrings[] =
-    {
-        "UNDEFINED",
-        "FLOAT",
-        "INT",
-        "STRING",
-        "TENSOR",
-        "GRAPH",
-        "FLOATS",
-        "INTS",
-        "STRINGS",
-        "TENSORS",
-        "GRAPHS"};
+static constexpr const char* kAttrTypeStrings[] = {
+    "UNDEFINED",
+    "FLOAT",
+    "INT",
+    "STRING",
+    "TENSOR",
+    "GRAPH",
+    "FLOATS",
+    "INTS",
+    "STRINGS",
+    "TENSORS",
+    "GRAPHS"};
 
 class TypeUtils {
  public:

onnxruntime/core/graph/op.h

@@ -4,15 +4,13 @@
 #if !defined(ORT_MINIMAL_BUILD) || defined(ORT_EXTENDED_MINIMAL_BUILD)
 
 #include "core/graph/runtime_optimization_record_container.h"
-
-#include <algorithm>
-
-#include <gsl/gsl>
-
 #include "core/flatbuffers/flatbuffers_utils.h"
 #include "core/flatbuffers/schema/ort.fbs.h"
 #include "core/graph/op_identifier_utils.h"
 
+#include <algorithm>
+#include <gsl/gsl>
+
 namespace onnxruntime {
 
 #if !defined(ORT_MINIMAL_BUILD)
@@ -182,7 +180,8 @@ Status RuntimeOptimizationRecordContainer::LoadFromOrtFormat(
     }
 
     ORT_RETURN_IF_NOT(optimizer_name_to_records.emplace(optimizer_name, std::move(records)).second,
-                      "Attempting to load runtime optimization records for a previously loaded optimizer: ", optimizer_name);
+                      "Attempting to load runtime optimization records for a previously loaded optimizer: ",
+                      optimizer_name);
   }
 
   optimizer_name_to_records_ = std::move(optimizer_name_to_records);