clang_format fixes

ChrisDodd · ChrisDodd · commit 75797953ef14 · 2026-06-03T05:33:26.000Z
Signed-off-by: Chris Dodd &lt;cdodd@nvidia.com&gt;
diff --git a/backends/tofino/bf-p4c/phv/analysis/mutex_overlay.cpp b/backends/tofino/bf-p4c/phv/analysis/mutex_overlay.cpp
@@ -54,7 +54,7 @@ bool ExcludeParserLoopReachableFields::is_loop_reachable(
 }
 
 IR::Ptr<IR::Node> ExcludeParserLoopReachableFields::apply_visitor(const IR::Node *root,
-                                                                const char *) {
+                                                                  const char *) {
     for (auto &kv : fieldToStates.field_to_parser_states) {
         for (auto &xk : fieldToStates.field_to_parser_states) {
             if (kv.first == xk.first || kv.first->gress != xk.first->gress) continue;
diff --git a/frontends/common/applyOptionsPragmas.cpp b/frontends/common/applyOptionsPragmas.cpp
@@ -44,9 +44,9 @@ std::optional<IOptionPragmaParser::CommandLineOptions> P4COptionPragmaParser::tr
     if (supportCommandLinePragma && pragmaName == "command_line") {
         IOptionPragmaParser::CommandLineOptions options;
         auto args = annotation->needsParsing()
-                         ? P4ParserDriver::parseExpressionList(annotation->srcInfo,
-                                                               annotation->getUnparsed())
-                         : IR::Ptr<IR::Vector<IR::Expression>>(&annotation->getExpr());
+                        ? P4ParserDriver::parseExpressionList(annotation->srcInfo,
+                                                              annotation->getUnparsed())
+                        : IR::Ptr<IR::Vector<IR::Expression>>(&annotation->getExpr());
         for (const IR::Expression *arg : *args) {
             if (auto *a = arg->to<IR::StringLiteral>()) {
                 options.push_back(a->value.c_str());
diff --git a/frontends/common/parseInput.cpp b/frontends/common/parseInput.cpp
@@ -29,7 +29,8 @@ IR::Ptr<IR::P4Program> parseP4String(const char *sourceFile, unsigned sourceLine
                                      const std::string &input,
                                      CompilerOptions::FrontendVersion version) {
     std::istringstream stream(input);
-    auto result = (version == CompilerOptions::FrontendVersion::P4_14)
+    auto result =
+        (version == CompilerOptions::FrontendVersion::P4_14)
             ? parseV1Program<std::istringstream &, P4V1::Converter>(stream, sourceFile, sourceLine)
             : P4ParserDriver::parse(stream, sourceFile, sourceLine);
 
diff --git a/frontends/p4/inlining.h b/frontends/p4/inlining.h
@@ -155,7 +155,8 @@ struct InlineSummary : public IHasDbPrint {
         /// For each instance (key) we must apply a bunch of substitutions
         std::map<IR::Ptr<IR::Declaration_Instance>, PerInstanceSubstitutions *> substitutions;
         /// For each invocation (key) call the instance that is invoked.
-        std::map<IR::Ptr<IR::MethodCallStatement>, IR::Ptr<IR::Declaration_Instance>> callToInstance;
+        std::map<IR::Ptr<IR::MethodCallStatement>, IR::Ptr<IR::Declaration_Instance>>
+            callToInstance;
 
         /**
          * For each distinct invocation of the subparser identified by InlinedInvocationInfo
diff --git a/frontends/p4/parseAnnotations.h b/frontends/p4/parseAnnotations.h
@@ -26,7 +26,7 @@ namespace P4 {
 // Parses an annotation with a single-element body.
 #define PARSE(aname, tname)                                                                    \
     {aname, [](IR::Annotation *annotation) {                                                   \
-         IR::Ptr<IR::tname> parsed =                                                             \
+         IR::Ptr<IR::tname> parsed =                                                           \
              P4::P4ParserDriver::parse##tname(annotation->srcInfo, annotation->getUnparsed()); \
          if (parsed != nullptr) {                                                              \
              annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);           \
@@ -35,19 +35,19 @@ namespace P4 {
      }}
 
 // Parses an annotation that is either an integer constant or a string literal.
-#define PARSE_CONSTANT_OR_STRING_LITERAL(aname)                                           \
-    {aname, [](IR::Annotation *annotation) {                                              \
+#define PARSE_CONSTANT_OR_STRING_LITERAL(aname)                                             \
+    {aname, [](IR::Annotation *annotation) {                                                \
          IR::Ptr<IR::Expression> parsed = P4::P4ParserDriver::parseConstantOrStringLiteral( \
-             annotation->srcInfo, annotation->getUnparsed());                             \
-         if (parsed != nullptr) {                                                         \
-             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);      \
-         }                                                                                \
-         return parsed != nullptr;                                                        \
+             annotation->srcInfo, annotation->getUnparsed());                               \
+         if (parsed != nullptr) {                                                           \
+             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);        \
+         }                                                                                  \
+         return parsed != nullptr;                                                          \
      }}
 
 #define PARSE_CONSTANT(aname)                                                                   \
     {aname, [](IR::Annotation *annotation) {                                                    \
-         IR::Ptr<IR::Expression> parsed =                                                         \
+         IR::Ptr<IR::Expression> parsed =                                                       \
              P4::P4ParserDriver::parseConstant(annotation->srcInfo, annotation->getUnparsed()); \
          if (parsed != nullptr) {                                                               \
              annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed);            \
@@ -57,7 +57,7 @@ namespace P4 {
 
 #define PARSE_STRING_LITERAL(aname)                                                  \
     {aname, [](IR::Annotation *annotation) {                                         \
-         IR::Ptr<IR::Expression> parsed = P4::P4ParserDriver::parseStringLiteral(      \
+         IR::Ptr<IR::Expression> parsed = P4::P4ParserDriver::parseStringLiteral(    \
              annotation->srcInfo, annotation->getUnparsed());                        \
          if (parsed != nullptr) {                                                    \
              annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(parsed); \
@@ -66,27 +66,27 @@ namespace P4 {
      }}
 
 // Parses an annotation whose body is a pair.
-#define PARSE_PAIR(aname, tname)                                                            \
-    {aname, [](IR::Annotation *annotation) {                                                \
-         IR::Ptr<IR::Vector<IR::Expression>> parsed = P4::P4ParserDriver::parse##tname##Pair( \
-             annotation->srcInfo, annotation->getUnparsed());                               \
-         if (parsed != nullptr) {                                                           \
-             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(*parsed);       \
-         }                                                                                  \
-         return parsed != nullptr;                                                          \
-     }}
-
-// Parses an annotation whose body is a triple.
-#define PARSE_TRIPLE(aname, tname)                                                            \
+#define PARSE_PAIR(aname, tname)                                                              \
     {aname, [](IR::Annotation *annotation) {                                                  \
-         IR::Ptr<IR::Vector<IR::Expression>> parsed = P4::P4ParserDriver::parse##tname##Triple( \
+         IR::Ptr<IR::Vector<IR::Expression>> parsed = P4::P4ParserDriver::parse##tname##Pair( \
              annotation->srcInfo, annotation->getUnparsed());                                 \
          if (parsed != nullptr) {                                                             \
              annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(*parsed);         \
          }                                                                                    \
          return parsed != nullptr;                                                            \
      }}
 
+// Parses an annotation whose body is a triple.
+#define PARSE_TRIPLE(aname, tname)                                                              \
+    {aname, [](IR::Annotation *annotation) {                                                    \
+         IR::Ptr<IR::Vector<IR::Expression>> parsed = P4::P4ParserDriver::parse##tname##Triple( \
+             annotation->srcInfo, annotation->getUnparsed());                                   \
+         if (parsed != nullptr) {                                                               \
+             annotation->body.emplace<IR::Annotation::ExpressionAnnotation>(*parsed);           \
+         }                                                                                      \
+         return parsed != nullptr;                                                              \
+     }}
+
 // Parses an annotation whose body is a list of expressions.
 #define PARSE_EXPRESSION_LIST(aname) {aname, &P4::ParseAnnotations::parseExpressionList}
 
diff --git a/frontends/p4/typeChecking/typeCheckDecl.cpp b/frontends/p4/typeChecking/typeCheckDecl.cpp
@@ -432,8 +432,7 @@ const IR::Node *TypeInferenceBase::postorder(const IR::SerEnumMember *member) {
     ConstantTypeSubstitution cts(tvs, typeMap, this);
     auto newValue = cts.convert(member->value, getChildContext());  // sets type
     IR::Ptr<IR::SerEnumMember> rv = member;
-    if (rv->value != newValue)
-        rv = new IR::SerEnumMember(rv->srcInfo, rv->name, newValue);
+    if (rv->value != newValue) rv = new IR::SerEnumMember(rv->srcInfo, rv->name, newValue);
     if (!typeMap->getType(rv)) setType(rv, getTypeType(serEnum));
     return rv;  // will always be in typeMap, so this won't dangle
 }
diff --git a/frontends/p4/typeChecking/typeChecker.cpp b/frontends/p4/typeChecking/typeChecker.cpp
@@ -73,7 +73,8 @@ IR::Ptr<IR::Expression> TypeInferenceBase::constantFold(const IR::Expression *ex
 // Make a clone of the type where all type variables in
 // the type parameters are replaced with fresh ones.
 // This should only be applied to canonical types.
-IR::Ptr<IR::Type> TypeInferenceBase::cloneWithFreshTypeVariables(const IR::IMayBeGenericType *type) {
+IR::Ptr<IR::Type> TypeInferenceBase::cloneWithFreshTypeVariables(
+    const IR::IMayBeGenericType *type) {
     TypeVariableSubstitution tvs;
     for (auto v : type->getTypeParameters()->parameters) {
         auto tv = new IR::Type_Var(v->srcInfo, v->getName());
@@ -189,7 +190,7 @@ TypeVariableSubstitution *TypeInferenceBase::unifyBase(
 
 template <class Ctor>
 IR::Ptr<IR::Type> TypeInferenceBase::canonicalizeFields(const IR::Type_StructLike *type,
-                                                      Ctor constructor) {
+                                                        Ctor constructor) {
     bool changes = false;
     IR::IndexedVector<IR::StructField> fields;
     for (auto field : type->fields) {
@@ -933,7 +934,7 @@ TypeInferenceBase::containerInstantiation(
 
     auto returnType = tvs->lookup(rettype);
     BUG_CHECK(returnType != nullptr, "Cannot infer constructor result type %1%", node);
-    return { returnType, newArgs };
+    return {returnType, newArgs};
 }
 
 const IR::Node *TypeInferenceBase::postorder(const IR::Argument *arg) {
diff --git a/frontends/p4/typeMap.cpp b/frontends/p4/typeMap.cpp
@@ -399,8 +399,6 @@ int TypeMap::widthBits(const IR::Type *type, const IR::Node *errorPosition, bool
     return -1;
 }
 
-void dump(TypeMap *typeMap) {
-    std::cout <<*typeMap << std::endl;
-}
+void dump(TypeMap *typeMap) { std::cout << *typeMap << std::endl; }
 
 }  // namespace P4
diff --git a/frontends/p4/typeMap.h b/frontends/p4/typeMap.h
@@ -63,7 +63,8 @@ class TypeMap final : public ProgramMap {
 #if !HAVE_LIBGC
         BUG_CHECK(element->check_referenced(), "checking unreferenced node in typeMap");
 #endif
-        return typeMap.count(element) != 0; }
+        return typeMap.count(element) != 0;
+    }
     void setType(IR::Ptr<IR::Node> element, const IR::Type *type);
     IR::Ptr<IR::Type> getType(const IR::Node *element, bool notNull = false) const;
     // unwraps a TypeType into its contents
diff --git a/frontends/parsers/parserDriver.h b/frontends/parsers/parserDriver.h
@@ -139,16 +139,16 @@ class P4ParserDriver final : public AbstractParserDriver {
 
     // Singletons ////////////////////////////////////////////////////////////
     static IR::Ptr<IR::Expression> parseExpression(const Util::SourceInfo &srcInfo,
-                                                 const IR::Vector<IR::AnnotationToken> &body);
+                                                   const IR::Vector<IR::AnnotationToken> &body);
 
     static IR::Ptr<IR::Constant> parseConstant(const Util::SourceInfo &srcInfo,
-                                             const IR::Vector<IR::AnnotationToken> &body);
+                                               const IR::Vector<IR::AnnotationToken> &body);
 
     static IR::Ptr<IR::Expression> parseConstantOrStringLiteral(
         const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
-    static IR::Ptr<IR::StringLiteral> parseStringLiteral(const Util::SourceInfo &srcInfo,
-                                                       const IR::Vector<IR::AnnotationToken> &body);
+    static IR::Ptr<IR::StringLiteral> parseStringLiteral(
+        const Util::SourceInfo &srcInfo, const IR::Vector<IR::AnnotationToken> &body);
 
     // Pairs /////////////////////////////////////////////////////////////////
     static IR::Ptr<IR::Vector<IR::Expression>> parseExpressionPair(
diff --git a/ir/inode.h b/ir/inode.h
@@ -43,11 +43,15 @@ template <class T>
 inline constexpr bool has_static_type_name_v = has_static_type_name<T>::value;
 
 #if HAVE_LIBGC
-template <class T> using Ptr = const T *;
-template <class T> using MutablePtr = T *;
+template <class T>
+using Ptr = const T *;
+template <class T>
+using MutablePtr = T *;
 #else
-template <class T> using Ptr = shared_ptr<const T>;
-template <class T> using MutablePtr = shared_ptr<T>;
+template <class T>
+using Ptr = shared_ptr<const T>;
+template <class T>
+using MutablePtr = shared_ptr<T>;
 #endif
 
 // node interface
diff --git a/ir/ir-traversal-internal.h b/ir/ir-traversal-internal.h
@@ -14,9 +14,9 @@
 #ifndef IR_IR_TRAVERSAL_INTERNAL_H_
 #define IR_IR_TRAVERSAL_INTERNAL_H_
 
+#include "ir/node.h"
 #include "lib/exceptions.h"
 #include "lib/rtti_utils.h"
-#include "ir/node.h"
 
 #ifndef IR_IR_TRAVERSAL_INTERNAL_ENABLE
 #error "This file must not be used directly"
diff --git a/ir/json_loader.h b/ir/json_loader.h
@@ -405,7 +405,7 @@ class JSONLoader {
     }
     template <typename T>
     void unpack_json(IR::shared_ptr<IR::IndexedVector<T>> &v) {
-        v = get_node(NodeFactoryFn(&IR::IndexedVector<T>::fromJSON)) ->as<IR::IndexedVector<T>>();
+        v = get_node(NodeFactoryFn(&IR::IndexedVector<T>::fromJSON))->as<IR::IndexedVector<T>>();
     }
     template <typename T>
     void unpack_json(IR::shared_ptr<const IR::IndexedVector<T>> &v) {
diff --git a/ir/pass_manager.cpp b/ir/pass_manager.cpp
@@ -81,8 +81,8 @@ IR::Ptr<IR::Node> PassManager::apply_visitor(const IR::Node *program_, const cha
         }
         try {
             try {
-                LOG1(log_indent << name() << " invoking " << v->name() << " on " <<
-                     program->node_type_name() << '[' << program->id << ']');
+                LOG1(log_indent << name() << " invoking " << v->name() << " on "
+                                << program->node_type_name() << '[' << program->id << ']');
                 program = program->apply(**it, getChildContext());
                 if (LOGGING(3)) {
                     size_t maxmem, mem = gc_mem_inuse(&maxmem);  // triggers gc
diff --git a/ir/shared_ptr.h b/ir/shared_ptr.h
@@ -14,8 +14,8 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-#ifndef _IR_SHARED_PTR_H_
-#define _IR_SHARED_PTR_H_
+#ifndef IR_SHARED_PTR_H_
+#define IR_SHARED_PTR_H_
 
 #include <atomic>
 #include <memory>
@@ -100,9 +100,9 @@ class shared_ptr {
     }
     template <class U,
               typename = typename std::enable_if<std::is_constructible<T *, U *>::value>::type>
-    shared_ptr(U *a) {
+    shared_ptr(U *a) {  // NOLINT(runtime/explicit)
         if ((ptr = a)) a->refcount++;
-    }  // NOLINT(runtime/explicit)
+    }
     shared_ptr<T> &operator=(const shared_ptr<T> &a) {
         if (ptr == a.ptr) return *this;
         if (ptr && !ptr->not_on_heap && --ptr->refcount == 0) delete ptr;
@@ -186,4 +186,4 @@ auto toString(const P4::IR::shared_ptr<T> &val) {
 
 }  // namespace P4::Util
 
-#endif /* _IR_SHARED_PTR_H_ */
+#endif /* IR_SHARED_PTR_H_ */
diff --git a/ir/visitor.h b/ir/visitor.h
@@ -148,16 +148,16 @@ class Visitor {
 #if !HAVE_LIBGC
     /* additional visit functions needed when using IR::shared_ptr -- we sometimes visit
      * raw pointer copies of an IR::Ptr */
-    void visit(const IR::Node * &n, const char *name = 0) { n = apply_visitor(n, name); }
-    void visit(const IR::Node * const &n, const char *name = 0) {
+    void visit(const IR::Node *&n, const char *name = 0) { n = apply_visitor(n, name); }
+    void visit(const IR::Node *const &n, const char *name = 0) {
         auto t = apply_visitor(n, name);
         if (t != n) visitor_const_error();
     }
-    void visit(const IR::Node * &n, const char *name, int cidx) {
+    void visit(const IR::Node *&n, const char *name, int cidx) {
         ctxt->child_index = cidx;
         n = apply_visitor(n, name);
     }
-    void visit(const IR::Node * const &n, const char *name, int cidx) {
+    void visit(const IR::Node *const &n, const char *name, int cidx) {
         ctxt->child_index = cidx;
         auto t = apply_visitor(n, name);
         if (t != n) visitor_const_error();
@@ -521,7 +521,7 @@ class Transform : public virtual Visitor {
      * of a raw pointer, but then we'd lose the ability to return a subclass where appropriate
      * and have the compiler's covariant return type handling fix it up, as that only works
      * with raw pointers */
-    template<class T>
+    template <class T>
     const T *guardReturn(const T *rv) const {
 #if !HAVE_LIBGC
         guard_hold = rv;
@@ -530,7 +530,7 @@ class Transform : public virtual Visitor {
     }
 
 #if !HAVE_LIBGC
-    template<class T>
+    template <class T>
     const T *guardReturn(IR::Ptr<T> rv) const {
         guard_hold = rv;
         return rv;
diff --git a/test/gtest/ir-splitter.cpp b/test/gtest/ir-splitter.cpp
@@ -68,7 +68,7 @@ struct SplitterTest : public ::testing::Test {
     }
 
     IR::Ptr<IR::IfStatement> ifs(const IR::Expression *cond, const IR::Statement *tr,
-                               const IR::Statement *fls = nullptr) {
+                                 const IR::Statement *fls = nullptr) {
         return new IR::IfStatement(cond, tr, fls);
     }
 
diff --git a/test/gtest/parser_unroll.cpp b/test/gtest/parser_unroll.cpp
@@ -32,8 +32,8 @@ IR::Ptr<IR::P4Parser> getParser(const IR::P4Program *program) {
 }
 
 /// Rewrites parser
-std::pair<IR::Ptr<IR::P4Parser>, IR::Ptr<IR::P4Parser>>
-rewriteParser(IR::Ptr<IR::P4Program> program, CompilerOptions &options) {
+std::pair<IR::Ptr<IR::P4Parser>, IR::Ptr<IR::P4Parser>> rewriteParser(
+    IR::Ptr<IR::P4Program> program, CompilerOptions &options) {
     P4::FrontEnd frontend;
     program = frontend.run(options, program);
     CHECK_NULL(program);

Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ bool ExcludeParserLoopReachableFields::is_loop_reachable(`
`54`	`54`	`}`
`55`	`55`
`56`	`56`	`IR::Ptr<IR::Node> ExcludeParserLoopReachableFields::apply_visitor(const IR::Node *root,`
`57`		`- const char *) {`
	`57`	`+ const char *) {`
`58`	`58`	`for (auto &kv : fieldToStates.field_to_parser_states) {`
`59`	`59`	`for (auto &xk : fieldToStates.field_to_parser_states) {`
`60`	`60`	`if (kv.first == xk.first \|\| kv.first->gress != xk.first->gress) continue;`
Original file line number	Diff line number	Diff line change
`@@ -399,8 +399,6 @@ int TypeMap::widthBits(const IR::Type type, const IR::Node errorPosition, bool`
`399`	`399`	`return -1;`
`400`	`400`	`}`
`401`	`401`
`402`		`-void dump(TypeMap *typeMap) {`
`403`		`- std::cout <<*typeMap << std::endl;`
`404`		`-}`
	`402`	`+void dump(TypeMap typeMap) { std::cout << typeMap << std::endl; }`
`405`	`403`
`406`	`404`	`} // namespace P4`