Prevent inlining into module instances

include/verilogAST/assign_inliner.hpp

@@ -109,6 +109,31 @@ class IndexBlacklister : public Blacklister {
   virtual std::unique_ptr<Index> visit(std::unique_ptr<Index> node);
 };
 
+class ModuleInstanceBlacklister : public Blacklister {
+  // Prevent inling wires into module instance nodes, e.g.
+  // wire z;
+  // assign b = a;
+  // assign z = i + a;  // <--- not inlined into .w below
+  // inner_module inner_module_inst (
+  //     .c(a),
+  //     .i(i),
+  //     .w(z),
+  //     .o(o)
+  // );
+  //
+  // We can make this configurable, but for now we keep it as the default since
+  // some tools do not support general expressions inside module instance
+  // statements
+ public:
+  ModuleInstanceBlacklister(
+      std::set<std::string> &wire_blacklist,
+      std::map<std::string, std::unique_ptr<Expression>> &assign_map)
+      : Blacklister(wire_blacklist, assign_map){};
+  using Blacklister::visit;
+  virtual std::unique_ptr<ModuleInstantiation> visit(
+      std::unique_ptr<ModuleInstantiation> node);
+};
+
 class AssignInliner : public Transformer {
   std::map<std::string, int> read_count;
   std::map<std::string, int> assign_count;

src/assign_inliner.cpp

@@ -51,6 +51,16 @@ std::unique_ptr<Index> IndexBlacklister::visit(std::unique_ptr<Index> node) {
   return node;
 }
 
+std::unique_ptr<ModuleInstantiation> ModuleInstanceBlacklister::visit(
+    std::unique_ptr<ModuleInstantiation> node) {
+  this->blacklist = true;
+  for (auto&& conn : *node->connections) {
+    conn.second = this->visit(std::move(conn.second));
+  }
+  this->blacklist = false;
+  return node;
+}
+
 std::unique_ptr<Identifier> WireReadCounter::visit(
     std::unique_ptr<Identifier> node) {
   this->read_count[node->toString()]++;
@@ -259,6 +269,10 @@ std::unique_ptr<Module> AssignInliner::visit(std::unique_ptr<Module> node) {
   SliceBlacklister slice_blacklist(this->wire_blacklist, this->assign_map);
   node = slice_blacklist.visit(std::move(node));
 
+  ModuleInstanceBlacklister module_instance_blacklister(this->wire_blacklist,
+                                                        this->assign_map);
+  node = module_instance_blacklister.visit(std::move(node));
+
   std::vector<std::unique_ptr<AbstractPort>> new_ports;
   for (auto&& item : node->ports) {
     new_ports.push_back(this->visit(std::move(item)));