odb: Add swapMaster sanity checker and fix net internality logic

src/odb/include/odb/db.h

@@ -2555,7 +2555,10 @@ class dbNet : public dbObject
   ///
   /// Check if this net is internal to the given module.
   /// A net is internal if all its iterms belong to instances within the module
-  /// and it has no bterms.
+  /// (excluding sub-modules) and it has no bterms.
+  /// - A dbNet is also considered internal if it has a corresponding modnet
+  /// connected to a module output port that is unconnected in its parent
+  /// module (isInternalTo == true).
   ///
   bool isInternalTo(dbModule* module) const;
 
@@ -8619,6 +8622,11 @@ class dbModNet : public dbObject
   ///
   std::vector<dbModNet*> getNextModNetsInFanout() const;
 
+  ///
+  /// Returns the first connected dbModNet in the parent module hierarchy.
+  ///
+  dbModNet* getFirstParentModNet() const;
+
   ///
   /// Traverses the hierarchy in search of the first mod net that satisfies the
   /// given condition.

src/odb/src/db/CMakeLists.txt

@@ -85,6 +85,7 @@ add_library(db
     dbGroupPowerNetItr.cpp
     dbGroupGroundNetItr.cpp
     dbGDSLib.cpp
+    dbSwapMasterSanityChecker.cpp
     # Generator Code Begin cpp
     dbAccessPoint.cpp
     dbBusPort.cpp

src/odb/src/db/dbModInst.cpp

@@ -32,6 +32,7 @@
 #include "dbModNet.h"
 #include "dbModuleModInstItr.h"
 #include "dbModuleModInstModITermItr.h"
+#include "dbSwapMasterSanityChecker.h"
 #include "odb/dbBlockCallBackObj.h"
 #include "odb/dbObject.h"
 #include "odb/dbSet.h"
@@ -775,6 +776,11 @@ dbModInst* dbModInst::swapMaster(dbModule* new_module)
     }
   }
 
+  if (logger->debugCheck(utl::ODB, "replace_design_check_sanity", 1)) {
+    dbSwapMasterSanityChecker checker(new_mod_inst, new_module, logger);
+    checker.run();
+  }
+
   return new_mod_inst;
 }
 

src/odb/src/db/dbModNet.cpp

@@ -264,6 +264,15 @@ void dbModNet::dump() const
                  getParent()->getName(),
                  getParent()->getId());
 
+  dbNet* related_net = findRelatedNet();
+  if (related_net != nullptr) {
+    logger->report("  Related dbNet: {} (id={})",
+                   related_net->getName(),
+                   related_net->getId());
+  } else {
+    logger->report("  Related dbNet: <null>");
+  }
+
   logger->report("  ModITerms ({}):", getModITerms().size());
   for (dbModITerm* moditerm : getModITerms()) {
     // For dbModITerm, get types from child dbModBTerm
@@ -730,6 +739,18 @@ std::vector<dbModNet*> dbModNet::getNextModNetsInFanout() const
   return next_modnets;
 }
 
+dbModNet* dbModNet::getFirstParentModNet() const
+{
+  for (dbModBTerm* mod_bterm : getModBTerms()) {
+    if (dbModITerm* parent_iterm = mod_bterm->getParentModITerm()) {
+      if (dbModNet* parent_net = parent_iterm->getModNet()) {
+        return parent_net;
+      }
+    }
+  }
+  return nullptr;
+}
+
 dbModNet* dbModNet::findInHierarchy(
     const std::function<bool(dbModNet*)>& condition,
     dbHierSearchDir dir) const

src/odb/src/db/dbModule.cpp

@@ -889,6 +889,12 @@ void _dbModule::copyModuleInsts(dbModule* old_module,
       }
 
       // Check if the flat net is an internal net within old_module
+      // - If the old net is an internal net, a new net should be created.
+      // - If the old net is an external net, a new net will be created later
+      //   by boundary IO handling logic.
+      // - Note that if old modnet is connected to a dbModBTerm and its
+      //   corresponding dbModITerm is unconnected (has_parent_modnet == false),
+      //   a new net should be created.
       // - If old_module is uninstantiated module, every net in the module is
       //   an internal net.
       //   e.g., No module instance.
@@ -901,6 +907,22 @@ void _dbModule::copyModuleInsts(dbModule* old_module,
       //         net_name = u0/_001_        <-- External net crossing module
       //                                        boundary.
       std::string old_net_name = old_net->getName();
+      dbModNet* old_mod_net = old_iterm->getModNet();
+      bool has_parent_modnet
+          = (old_mod_net && old_mod_net->getFirstParentModNet());
+      if (old_net->isInternalTo(old_module) == false && has_parent_modnet) {
+        // Skip external net crossing module boundary.
+        // It will be connected later.
+        debugPrint(logger,
+                   utl::ODB,
+                   "replace_design",
+                   3,
+                   "    Skip: non-internal dbNet '{}' of old_module '{}'.\n",
+                   old_net_name,
+                   old_module->getHierarchicalName());
+        continue;
+      }
+
       new_net_name += block->getBaseName(old_net_name.c_str());
       auto it = new_net_name_map.find(new_net_name);
       if (it != new_net_name_map.end()) {