clang-format

Signed-off-by: Mihai Budiu <[email protected]>
p4lang · Nov 19, 2022 · f574efc · f574efc
1 parent 992b473
commit f574efc
Show file tree

Hide file tree

Showing 4 changed files with 15 additions and 20 deletions.
diff --git a/backends/p4test/midend.h b/backends/p4test/midend.h
@@ -25,6 +25,7 @@ namespace P4Test {
 
 class MidEnd : public PassManager {
     std::vector<DebugHook> hooks;
+
  public:
     P4::ReferenceMap refMap;
     P4::TypeMap typeMap;

diff --git a/frontends/p4/evaluator/evaluator.cpp b/frontends/p4/evaluator/evaluator.cpp
@@ -306,7 +306,7 @@ bool Evaluator::preorder(const IR::ListExpression* list) {
     return false;
 }
 
-bool Evaluator::preorder(const IR::P4ListExpression *list) {
+bool Evaluator::preorder(const IR::P4ListExpression* list) {
     LOG2("Evaluating " << list);
     visit(list->components);
     IR::Vector<IR::Node> comp;
@@ -322,7 +322,7 @@ bool Evaluator::preorder(const IR::P4ListExpression *list) {
     return false;
 }
 
-bool Evaluator::preorder(const IR::StructExpression *se) {
+bool Evaluator::preorder(const IR::StructExpression* se) {
     LOG2("Evaluating " << se);
     visit(se->components);
     IR::Vector<IR::Node> comp;

diff --git a/frontends/p4/typeChecking/typeChecker.cpp b/frontends/p4/typeChecking/typeChecker.cpp
@@ -356,8 +356,7 @@ const IR::Type* TypeInference::canonicalize(const IR::Type* type) {
         return canon;
     } else if (auto vec = type->to<IR::Type_P4List>()) {
         auto et = canonicalize(vec->elementType);
-        if (et == nullptr)
-            return nullptr;
+        if (et == nullptr) return nullptr;
         const IR::Type* canon;
         if (et == vec->elementType)
             canon = type;
@@ -2069,16 +2068,13 @@ const IR::Node* TypeInference::postorder(IR::P4ListExpression* expression) {
     auto vec = new IR::Vector<IR::Expression>();
     bool changed = false;
     for (auto c : expression->components) {
-        if (!isCompileTimeConstant(c))
-            constant = false;
+        if (!isCompileTimeConstant(c)) constant = false;
         auto type = getType(c);
-        if (type == nullptr)
-            return expression;
+        if (type == nullptr) return expression;
         auto tvs = unify(expression, elementType, type,
                          "Vector element type '%1%' does not match expected type '%2%'",
-                         { type, elementType });
-        if (tvs == nullptr)
-            return expression;
+                         {type, elementType});
+        if (tvs == nullptr) return expression;
         if (!tvs->isIdentity()) {
             ConstantTypeSubstitution cts(tvs, refMap, typeMap, this);
             auto converted = cts.convert(c);
@@ -2721,8 +2717,7 @@ const IR::Node* TypeInference::postorder(IR::Cast* expression) {
             for (size_t i = 0; i < le->size(); i++) {
                 auto compI = le->components.at(i);
                 auto src = assignment(expression, listElementType, compI);
-                if (!isCompileTimeConstant(src))
-                    isConstant = false;
+                if (!isCompileTimeConstant(src)) isConstant = false;
                 vec.push_back(src);
             }
             auto vecType = castType->getP4Type();

diff --git a/midend/eliminateTuples.h b/midend/eliminateTuples.h
@@ -83,7 +83,10 @@ class DoReplaceTuples final : public Transform {
         : repl(new ReplacementMap(refMap, typeMap)) {
         setName("DoReplaceTuples");
     }
-    const IR::Node* skip(const IR::Node* node) { prune(); return node; }
+    const IR::Node* skip(const IR::Node* node) {
+        prune();
+        return node;
+    }
     const IR::Node* postorder(IR::Type_BaseList* type) override;
     const IR::Node* insertReplacements(const IR::Node* before);
     const IR::Node* postorder(IR::Type_Struct* type) override { return insertReplacements(type); }
@@ -104,12 +107,8 @@ class DoReplaceTuples final : public Transform {
         // We want to keep these as tuples.
         return skip(set);
     }
-    const IR::Node* preorder(IR::P4ListExpression* expression) override {
-        return skip(expression);
-    }
-    const IR::Node* preorder(IR::Type_P4List* list) override {
-        return skip(list);
-    }
+    const IR::Node* preorder(IR::P4ListExpression* expression) override { return skip(expression); }
+    const IR::Node* preorder(IR::Type_P4List* list) override { return skip(list); }
 };
 
 class EliminateTuples final : public PassManager {