Refactor code to avoid duplication

leonardt · Jun 5, 2020 · 3d5f338 · 3d5f338
1 parent 0b5147f
commit 3d5f338
Show file tree

Hide file tree

Showing 2 changed files with 34 additions and 37 deletions.
diff --git a/include/verilogAST/assign_inliner.hpp b/include/verilogAST/assign_inliner.hpp
@@ -14,6 +14,9 @@ class AssignMapBuilder : public Transformer {
   std::set<std::string> &output_ports;
   std::set<std::string> &input_ports;
 
+  template <typename T>
+  std::unique_ptr<T> process_assign(std::unique_ptr<T> node);
+
  public:
   AssignMapBuilder(
       std::map<std::string, int> &assign_count,
@@ -39,6 +42,9 @@ class WireReadCounter : public Transformer {
   //
   std::map<std::string, int> &read_count;
 
+  template <typename T>
+  std::unique_ptr<T> process_assign(std::unique_ptr<T> node);
+
  public:
   WireReadCounter(std::map<std::string, int> &read_count)
       : read_count(read_count){};
@@ -92,6 +98,9 @@ class AssignInliner : public Transformer {
 
   bool can_inline(std::string key);
 
+  template <typename T>
+  std::unique_ptr<T> process_assign(std::unique_ptr<T> node);
+
  public:
   AssignInliner() : wire_blacklist(){};
   explicit AssignInliner(std::set<std::string> wire_blacklist)

diff --git a/src/assign_inliner.cpp b/src/assign_inliner.cpp
@@ -29,16 +29,20 @@ std::unique_ptr<Declaration> WireReadCounter::visit(
   return node;
 }
 
-std::unique_ptr<ContinuousAssign> WireReadCounter::visit(
-    std::unique_ptr<ContinuousAssign> node) {
+template <typename T>
+std::unique_ptr<T> WireReadCounter::process_assign(std::unique_ptr<T> node) {
   node->value = this->visit(std::move(node->value));
   return node;
 }
 
+std::unique_ptr<ContinuousAssign> WireReadCounter::visit(
+    std::unique_ptr<ContinuousAssign> node) {
+  return this->process_assign(std::move(node));
+}
+
 std::unique_ptr<BlockingAssign> WireReadCounter::visit(
     std::unique_ptr<BlockingAssign> node) {
-  node->value = this->visit(std::move(node->value));
-  return node;
+  return this->process_assign(std::move(node));
 }
 
 std::unique_ptr<Port> AssignMapBuilder::visit(std::unique_ptr<Port> node) {
@@ -63,9 +67,8 @@ std::unique_ptr<Port> AssignMapBuilder::visit(std::unique_ptr<Port> node) {
   }
   return node;
 }
-
-std::unique_ptr<BlockingAssign> AssignMapBuilder::visit(
-    std::unique_ptr<BlockingAssign> node) {
+template <typename T>
+std::unique_ptr<T> AssignMapBuilder::process_assign(std::unique_ptr<T> node) {
   node = Transformer::visit(std::move(node));
   std::string key =
       std::visit([](auto&& value) -> std::string { return value->toString(); },
@@ -75,15 +78,14 @@ std::unique_ptr<BlockingAssign> AssignMapBuilder::visit(
   return node;
 }
 
+std::unique_ptr<BlockingAssign> AssignMapBuilder::visit(
+    std::unique_ptr<BlockingAssign> node) {
+  return this->process_assign(std::move(node));
+}
+
 std::unique_ptr<ContinuousAssign> AssignMapBuilder::visit(
     std::unique_ptr<ContinuousAssign> node) {
-  node = Transformer::visit(std::move(node));
-  std::string key =
-      std::visit([](auto&& value) -> std::string { return value->toString(); },
-                 node->target);
-  this->assign_map[key] = node->value->clone();
-  this->assign_count[key]++;
-  return node;
+  return this->process_assign(std::move(node));
 }
 
 bool AssignInliner::can_inline(std::string key) {
@@ -129,8 +131,8 @@ std::unique_ptr<Wire> AssignInliner::visit(std::unique_ptr<Wire> node) {
   return node;
 }
 
-std::unique_ptr<ContinuousAssign> AssignInliner::visit(
-    std::unique_ptr<ContinuousAssign> node) {
+template <typename T>
+std::unique_ptr<T> AssignInliner::process_assign(std::unique_ptr<T> node) {
   node->value = this->visit(std::move(node->value));
   std::string key =
       std::visit([](auto&& value) -> std::string { return value->toString(); },
@@ -148,33 +150,19 @@ std::unique_ptr<ContinuousAssign> AssignInliner::visit(
       },
       node->target);
   if (remove) {
-    return std::unique_ptr<ContinuousAssign>{};
+    return std::unique_ptr<T>{};
   }
   return node;
 }
 
+std::unique_ptr<ContinuousAssign> AssignInliner::visit(
+    std::unique_ptr<ContinuousAssign> node) {
+  return this->process_assign(std::move(node));
+}
+
 std::unique_ptr<BlockingAssign> AssignInliner::visit(
     std::unique_ptr<BlockingAssign> node) {
-  node->value = this->visit(std::move(node->value));
-  std::string key =
-      std::visit([](auto&& value) -> std::string { return value->toString(); },
-                 node->target);
-  bool remove = false;
-  std::visit(
-      [&](auto&& value) {
-        if (auto ptr = dynamic_cast<Identifier*>(value.get())) {
-          if (this->can_inline(key) && this->non_input_ports.count(key) == 0) {
-            remove = true;
-          } else if (this->inlined_outputs.count(ptr->toString())) {
-            remove = true;
-          };
-        }
-      },
-      node->target);
-  if (remove) {
-    return std::unique_ptr<BlockingAssign>{};
-  }
-  return node;
+  return this->process_assign(std::move(node));
 }
 
 std::vector<std::variant<std::unique_ptr<StructuralStatement>,