module::delete_net() implemented

joern274 · joern274 · commit be060adead55 · 2025-04-12T11:54:19.000+02:00
diff --git a/include/hal_core/netlist/module.h b/include/hal_core/netlist/module.h
@@ -747,7 +747,8 @@ namespace hal
         EventHandler* m_event_handler;
 
         NetConnectivity check_net_endpoints(const Net* net) const;
-        Result<std::monostate> check_net(Net* net, bool recursive = false);
+        bool check_net(Net* net, bool recursive = false);
+        bool delete_net(Net* net, bool recursive = false);
         bool assign_pin_net(const u32 pin_id, Net* net, PinDirection direction);
         bool remove_pin_net(Net* net);
         Result<ModulePin*> create_pin_internal(const u32 id, const std::string& name, Net* net, PinDirection direction, PinType type, bool force_name);
diff --git a/include/hal_core/netlist/netlist_internal_manager.h b/include/hal_core/netlist/netlist_internal_manager.h
@@ -74,9 +74,11 @@ namespace hal
         Net* create_net(u32 id, const std::string& name);
         bool delete_net(Net* net);
         Endpoint* net_add_source(Net* net, Gate* gate, GatePin* pin);
-        bool net_remove_source(Net* net, Endpoint* ep);
         Endpoint* net_add_destination(Net* net, Gate* gate, GatePin* pin);
+        bool net_remove_source(Net* net, Endpoint* ep);
+        bool net_remove_source_internal(Net* net, Endpoint* ep);
         bool net_remove_destination(Net* net, Endpoint* ep);
+        bool net_remove_destination_internal(Net* net, Endpoint* ep);
 
         // module functions
         Module* create_module(u32 id, Module* parent, const std::string& name);
diff --git a/src/netlist/module.cpp b/src/netlist/module.cpp
@@ -204,10 +204,7 @@ namespace hal
         {
             for (Net* net : get_nets(nullptr, true))
             {
-                if (auto res = m_parent->check_net(net, true); res.is_error())
-                {
-                    log_error("module", "{}", res.get_error().get());
-                }
+                m_parent->check_net(net, true);
             }
         }
 
@@ -222,10 +219,7 @@ namespace hal
         {
             for (Net* net : get_nets(nullptr, true))
             {
-                if (auto res = m_parent->check_net(net, true); res.is_error())
-                {
-                    log_error("module", "{}", res.get_error().get());
-                }
+                m_parent->check_net(net, true);
             }
         }
 
@@ -241,16 +235,19 @@ namespace hal
         {
             return false;
         }
-        for (auto sm : m_submodules)
+
+        Module* parent_module = module->m_parent;
+        while (parent_module)
         {
-            if (sm == module)
+            if (parent_module == this)
             {
                 return true;
             }
-            else if (recursive && sm->is_parent_module_of(module, true))
+            if (!recursive)
             {
-                return true;
+                break;
             }
+            parent_module = parent_module->m_parent;
         }
 
         return false;
@@ -630,7 +627,31 @@ namespace hal
         return res;
     }
 
-    Result<std::monostate> Module::check_net(Net* net, bool recursive)
+    bool Module::delete_net(Net* net, bool recursive)
+    {
+        if (!m_internal_manager->m_net_checks_enabled)
+        {
+            return true; // do nothing, no error either to reproduce check_net() behavior
+        }
+
+        m_internal_nets.erase(net);
+        m_nets.erase(net);
+        m_input_nets.erase(net);
+        m_output_nets.erase(net);
+
+        if (m_internal_manager->m_net_checks_enabled && recursive && m_parent != nullptr)
+        {
+            if (!m_parent->delete_net(net, recursive))
+            {
+                return false;
+            }
+        }
+
+        return true;
+
+    }
+
+    bool Module::check_net(Net* net, bool recursive)
     {
         NetConnectivity con = check_net_endpoints(net);
         if (con.has_internal_source && con.has_internal_destination)
@@ -673,7 +694,8 @@ namespace hal
             {
                 if (!assign_pin_net(get_unique_pin_id(), net, PinDirection::inout))
                 {
-                    return ERR("could not assign inout pin to net ID " + std::to_string(net->get_id()) + ": failed to create pin");
+                    log_warning("module", "could not assign inout pin to net ID {}: failed to create pin", net->get_id() );
+                    return false;
                 }
             }
         }
@@ -695,7 +717,8 @@ namespace hal
                 m_input_nets.insert(net);
                 if (!assign_pin_net(get_unique_pin_id(), net, PinDirection::input))
                 {
-                    return ERR("could not assign input pin to net ID " + std::to_string(net->get_id()) + ": failed to create pin");
+                    log_warning("module", "could not assign input pin to net ID {}: failed to create pin", net->get_id() );
+                    return false;
                 }
             }
         }
@@ -717,7 +740,8 @@ namespace hal
                 m_output_nets.insert(net);
                 if (!assign_pin_net(get_unique_pin_id(), net, PinDirection::output))
                 {
-                    return ERR("could not assign output pin to net ID " + std::to_string(net->get_id()) + ": failed to create pin");
+                    log_warning("module", "could not assign output pin to net ID {}: failed to create pin", net->get_id() );
+                    return false;
                 }
             }
         }
@@ -736,20 +760,21 @@ namespace hal
                 }
                 if (!remove_pin_net(net))
                 {
-                    return ERR("Remove pin net failed");
+                    log_warning("module", "Remove pin net failed");
+                    return false;
                 }
             }
         }
 
         if (m_internal_manager->m_net_checks_enabled && recursive && m_parent != nullptr)
         {
-            if (auto res = m_parent->check_net(net, true); res.is_error())
+            if (!m_parent->check_net(net, true))
             {
-                return res;
+                return false;
             }
         }
 
-        return OK({});
+        return true;
     }
 
     /*
diff --git a/src/netlist/netlist.cpp b/src/netlist/netlist.cpp
@@ -7,6 +7,7 @@
 #include "hal_core/netlist/net.h"
 #include "hal_core/netlist/netlist_internal_manager.h"
 #include "hal_core/utilities/log.h"
+#include <valgrind/callgrind.h>
 
 namespace hal
 {
@@ -342,7 +343,11 @@ namespace hal
 
     bool Netlist::delete_net(Net* n)
     {
+        CALLGRIND_START_INSTRUMENTATION;
+        CALLGRIND_TOGGLE_COLLECT;
         return m_manager->delete_net(n);
+        CALLGRIND_TOGGLE_COLLECT;
+        CALLGRIND_STOP_INSTRUMENTATION;
     }
 
     bool Netlist::is_net_in_netlist(const Net* n) const
diff --git a/src/netlist/netlist_internal_manager.cpp b/src/netlist/netlist_internal_manager.cpp
@@ -445,7 +445,7 @@ namespace hal
         auto dsts = net->m_destinations_raw;
         for (auto dst : dsts)
         {
-            if (!this->net_remove_destination(net, dst))
+            if (!this->net_remove_destination_internal(net, dst))
             {
                 return false;
             }
@@ -454,7 +454,7 @@ namespace hal
         auto srcs = net->m_sources_raw;
         for (auto src : srcs)
         {
-            if (!this->net_remove_source(net, src))
+            if (!this->net_remove_source_internal(net, src))
             {
                 return false;
             }
@@ -540,17 +540,15 @@ namespace hal
         // update internal nets and port nets
         if (m_net_checks_enabled)
         {
-            if (const auto res = gate->get_module()->check_net(net, true); res.is_error())
+            if (!gate->get_module()->check_net(net, true))
             {
-                log_error("net", "{}", res.get_error().get());
                 return nullptr;
             }
 
             for (Endpoint* ep : net->get_destinations())
             {
-                if (const auto res = ep->get_gate()->get_module()->check_net(net, true); res.is_error())
+                if (!ep->get_gate()->get_module()->check_net(net, true))
                 {
-                    log_error("net", "{}", res.get_error().get());
                     return nullptr;
                 }
             }
@@ -561,7 +559,7 @@ namespace hal
         return new_endpoint_raw;
     }
 
-    bool NetlistInternalManager::net_remove_source(Net* net, Endpoint* ep)
+    bool NetlistInternalManager::net_remove_source_internal(Net* net, Endpoint* ep)
     {
         auto gate = ep->get_gate();
 
@@ -570,7 +568,6 @@ namespace hal
             return false;
         }
 
-        bool removed = false;
         for (u32 i = 0; i < net->m_sources.size(); ++i)
         {
             if (net->m_sources_raw[i] == ep)
@@ -582,12 +579,18 @@ namespace hal
                 net->m_sources_raw[i] = net->m_sources_raw.back();
                 net->m_sources_raw.pop_back();
                 m_event_handler->notify(NetEvent::event::src_removed, net, gate->get_id());
-                removed = true;
-                break;
+                return true;
             }
         }
 
-        if (!removed)
+        return false;
+    }
+
+    bool NetlistInternalManager::net_remove_source(Net* net, Endpoint* ep)
+    {
+        auto gate = ep->get_gate();
+
+        if (!net_remove_source_internal(net, ep))
         {
             log_warning("net",
                         "output pin '{}' of gate '{}' with ID {} is not a source of net '{}' with ID {} in netlist with ID {}",
@@ -603,17 +606,15 @@ namespace hal
             // update internal nets and port nets
             if (m_net_checks_enabled)
             {
-                if (const auto res = gate->get_module()->check_net(net, true); res.is_error())
+                if (!gate->get_module()->check_net(net, true))
                 {
-                    log_error("net", "{}", res.get_error().get());
                     return false;
                 }
 
                 for (Endpoint* dst : net->get_destinations())
                 {
-                    if (const auto res = dst->get_gate()->get_module()->check_net(net, true); res.is_error())
+                    if (!dst->get_gate()->get_module()->check_net(net, true))
                     {
-                        log_error("net", "{}", res.get_error().get());
                         return false;
                     }
                 }
@@ -678,17 +679,15 @@ namespace hal
         // update internal nets and port nets
         if (m_net_checks_enabled)
         {
-            if (const auto res = gate->get_module()->check_net(net, true); res.is_error())
+            if (!gate->get_module()->check_net(net, true))
             {
-                log_error("net", "{}", res.get_error().get());
                 return nullptr;
             }
 
             for (Endpoint* ep : net->get_sources())
             {
-                if (const auto res = ep->get_gate()->get_module()->check_net(net, true); res.is_error())
+                if (!ep->get_gate()->get_module()->check_net(net, true))
                 {
-                    log_error("net", "{}", res.get_error().get());
                     return nullptr;
                 }
             }
@@ -699,15 +698,15 @@ namespace hal
         return new_endpoint_raw;
     }
 
-    bool NetlistInternalManager::net_remove_destination(Net* net, Endpoint* ep)
+    bool NetlistInternalManager::net_remove_destination_internal(Net* net, Endpoint* ep)
     {
         auto gate = ep->get_gate();
+
         if (!m_netlist->is_net_in_netlist(net) || !m_netlist->is_gate_in_netlist(gate) || !net->is_a_destination(ep))
         {
             return false;
         }
 
-        bool removed = false;
         for (u32 i = 0; i < net->m_destinations.size(); ++i)
         {
             if (net->m_destinations_raw[i] == ep)
@@ -719,12 +718,18 @@ namespace hal
                 net->m_destinations_raw[i] = net->m_destinations_raw.back();
                 net->m_destinations_raw.pop_back();
                 m_event_handler->notify(NetEvent::event::dst_removed, net, gate->get_id());
-                removed = true;
-                break;
+                return true;
             }
         }
 
-        if (!removed)
+        return false;
+    }
+
+    bool NetlistInternalManager::net_remove_destination(Net* net, Endpoint* ep)
+    {
+        auto gate = ep->get_gate();
+
+        if (!net_remove_destination_internal(net,ep))
         {
             log_warning("net",
                         "input pin '{}' of gate '{}' with ID {} is not a destination of net '{}' with ID {} in netlist with ID {}",
@@ -739,17 +744,15 @@ namespace hal
         {    // update internal nets and port nets
             if (m_net_checks_enabled)
             {
-                if (const auto res = gate->get_module()->check_net(net, true); res.is_error())
+                if (!gate->get_module()->check_net(net, true))
                 {
-                    log_error("net", "{}", res.get_error().get());
                     return false;
                 }
 
                 for (Endpoint* src : net->get_sources())
                 {
-                    if (const auto res = src->get_gate()->get_module()->check_net(net, true); res.is_error())
+                    if (!src->get_gate()->get_module()->check_net(net, true))
                     {
-                        log_error("net", "{}", res.get_error().get());
                         return false;
                     }
                 }
@@ -977,9 +980,8 @@ namespace hal
             {
                 for (Net* net : nets)
                 {
-                    if (const auto res = affected_module->check_net(net, true); res.is_error())
+                    if (!affected_module->check_net(net, true))
                     {
-                        log_error("module", "{}", res.get_error().get());
                         return false;
                     }
                 }
@@ -997,11 +999,7 @@ namespace hal
 
     bool NetlistInternalManager::module_check_net(Module* module, Net* net, bool recursive)
     {
-        if (const auto res = module->check_net(net, recursive); res.is_error())
-        {
-            return false;
-        }
-        return true;
+        return module->check_net(net, recursive);
     }
 
     //######################################################################

Original file line number	Diff line number	Diff line change
`@@ -204,10 +204,7 @@ namespace hal`
`204`	`204`	`{`
`205`	`205`	`for (Net* net : get_nets(nullptr, true))`
`206`	`206`	`{`
`207`		`- if (auto res = m_parent->check_net(net, true); res.is_error())`
`208`		`- {`
`209`		`- log_error("module", "{}", res.get_error().get());`
`210`		`- }`
	`207`	`+ m_parent->check_net(net, true);`
`211`	`208`	`}`
`212`	`209`	`}`
`213`	`210`
`@@ -222,10 +219,7 @@ namespace hal`
`222`	`219`	`{`
`223`	`220`	`for (Net* net : get_nets(nullptr, true))`
`224`	`221`	`{`
`225`		`- if (auto res = m_parent->check_net(net, true); res.is_error())`
`226`		`- {`
`227`		`- log_error("module", "{}", res.get_error().get());`
`228`		`- }`
	`222`	`+ m_parent->check_net(net, true);`
`229`	`223`	`}`
`230`	`224`	`}`
`231`	`225`
`@@ -241,16 +235,19 @@ namespace hal`
`241`	`235`	`{`
`242`	`236`	`return false;`
`243`	`237`	`}`
`244`		`- for (auto sm : m_submodules)`
	`238`	`+`
	`239`	`+ Module* parent_module = module->m_parent;`
	`240`	`+ while (parent_module)`
`245`	`241`	`{`
`246`		`- if (sm == module)`
	`242`	`+ if (parent_module == this)`
`247`	`243`	`{`
`248`	`244`	`return true;`
`249`	`245`	`}`
`250`		`- else if (recursive && sm->is_parent_module_of(module, true))`
	`246`	`+ if (!recursive)`
`251`	`247`	`{`
`252`		`- return true;`
	`248`	`+ break;`
`253`	`249`	`}`
	`250`	`+ parent_module = parent_module->m_parent;`
`254`	`251`	`}`
`255`	`252`
`256`	`253`	`return false;`
`@@ -630,7 +627,31 @@ namespace hal`
`630`	`627`	`return res;`
`631`	`628`	`}`
`632`	`629`
`633`		`- Result<std::monostate> Module::check_net(Net* net, bool recursive)`
	`630`	`+ bool Module::delete_net(Net* net, bool recursive)`
	`631`	`+ {`
	`632`	`+ if (!m_internal_manager->m_net_checks_enabled)`
	`633`	`+ {`
	`634`	`+ return true; // do nothing, no error either to reproduce check_net() behavior`
	`635`	`+ }`
	`636`	`+`
	`637`	`+ m_internal_nets.erase(net);`
	`638`	`+ m_nets.erase(net);`
	`639`	`+ m_input_nets.erase(net);`
	`640`	`+ m_output_nets.erase(net);`
	`641`	`+`
	`642`	`+ if (m_internal_manager->m_net_checks_enabled && recursive && m_parent != nullptr)`
	`643`	`+ {`
	`644`	`+ if (!m_parent->delete_net(net, recursive))`
	`645`	`+ {`
	`646`	`+ return false;`
	`647`	`+ }`
	`648`	`+ }`
	`649`	`+`
	`650`	`+ return true;`
	`651`	`+`
	`652`	`+ }`
	`653`	`+`
	`654`	`+ bool Module::check_net(Net* net, bool recursive)`
`634`	`655`	`{`
`635`	`656`	`NetConnectivity con = check_net_endpoints(net);`
`636`	`657`	`if (con.has_internal_source && con.has_internal_destination)`
`@@ -673,7 +694,8 @@ namespace hal`
`673`	`694`	`{`
`674`	`695`	`if (!assign_pin_net(get_unique_pin_id(), net, PinDirection::inout))`
`675`	`696`	`{`
`676`		`- return ERR("could not assign inout pin to net ID " + std::to_string(net->get_id()) + ": failed to create pin");`
	`697`	`+ log_warning("module", "could not assign inout pin to net ID {}: failed to create pin", net->get_id() );`
	`698`	`+ return false;`
`677`	`699`	`}`
`678`	`700`	`}`
`679`	`701`	`}`
`@@ -695,7 +717,8 @@ namespace hal`
`695`	`717`	`m_input_nets.insert(net);`
`696`	`718`	`if (!assign_pin_net(get_unique_pin_id(), net, PinDirection::input))`
`697`	`719`	`{`
`698`		`- return ERR("could not assign input pin to net ID " + std::to_string(net->get_id()) + ": failed to create pin");`
	`720`	`+ log_warning("module", "could not assign input pin to net ID {}: failed to create pin", net->get_id() );`
	`721`	`+ return false;`
`699`	`722`	`}`
`700`	`723`	`}`
`701`	`724`	`}`
`@@ -717,7 +740,8 @@ namespace hal`
`717`	`740`	`m_output_nets.insert(net);`
`718`	`741`	`if (!assign_pin_net(get_unique_pin_id(), net, PinDirection::output))`
`719`	`742`	`{`
`720`		`- return ERR("could not assign output pin to net ID " + std::to_string(net->get_id()) + ": failed to create pin");`
	`743`	`+ log_warning("module", "could not assign output pin to net ID {}: failed to create pin", net->get_id() );`
	`744`	`+ return false;`
`721`	`745`	`}`
`722`	`746`	`}`
`723`	`747`	`}`
`@@ -736,20 +760,21 @@ namespace hal`
`736`	`760`	`}`
`737`	`761`	`if (!remove_pin_net(net))`
`738`	`762`	`{`
`739`		`- return ERR("Remove pin net failed");`
	`763`	`+ log_warning("module", "Remove pin net failed");`
	`764`	`+ return false;`
`740`	`765`	`}`
`741`	`766`	`}`
`742`	`767`	`}`
`743`	`768`
`744`	`769`	`if (m_internal_manager->m_net_checks_enabled && recursive && m_parent != nullptr)`
`745`	`770`	`{`
`746`		`- if (auto res = m_parent->check_net(net, true); res.is_error())`
	`771`	`+ if (!m_parent->check_net(net, true))`
`747`	`772`	`{`
`748`		`- return res;`
	`773`	`+ return false;`
`749`	`774`	`}`
`750`	`775`	`}`
`751`	`776`
`752`		`- return OK({});`
	`777`	`+ return true;`
`753`	`778`	`}`
`754`	`779`
`755`	`780`	`/*`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@`
`7`	`7`	`#include "hal_core/netlist/net.h"`
`8`	`8`	`#include "hal_core/netlist/netlist_internal_manager.h"`
`9`	`9`	`#include "hal_core/utilities/log.h"`
	`10`	`+#include <valgrind/callgrind.h>`
`10`	`11`
`11`	`12`	`namespace hal`
`12`	`13`	`{`
`@@ -342,7 +343,11 @@ namespace hal`
`342`	`343`
`343`	`344`	`bool Netlist::delete_net(Net* n)`
`344`	`345`	`{`
	`346`	`+ CALLGRIND_START_INSTRUMENTATION;`
	`347`	`+ CALLGRIND_TOGGLE_COLLECT;`
`345`	`348`	`return m_manager->delete_net(n);`
	`349`	`+ CALLGRIND_TOGGLE_COLLECT;`
	`350`	`+ CALLGRIND_STOP_INSTRUMENTATION;`
`346`	`351`	`}`
`347`	`352`
`348`	`353`	`bool Netlist::is_net_in_netlist(const Net* n) const`
Original file line number	Diff line number	Diff line change
`@@ -445,7 +445,7 @@ namespace hal`
`445`	`445`	`auto dsts = net->m_destinations_raw;`
`446`	`446`	`for (auto dst : dsts)`
`447`	`447`	`{`
`448`		`- if (!this->net_remove_destination(net, dst))`
	`448`	`+ if (!this->net_remove_destination_internal(net, dst))`
`449`	`449`	`{`
`450`	`450`	`return false;`
`451`	`451`	`}`
`@@ -454,7 +454,7 @@ namespace hal`
`454`	`454`	`auto srcs = net->m_sources_raw;`
`455`	`455`	`for (auto src : srcs)`
`456`	`456`	`{`
`457`		`- if (!this->net_remove_source(net, src))`
	`457`	`+ if (!this->net_remove_source_internal(net, src))`
`458`	`458`	`{`
`459`	`459`	`return false;`
`460`	`460`	`}`
`@@ -540,17 +540,15 @@ namespace hal`
`540`	`540`	`// update internal nets and port nets`
`541`	`541`	`if (m_net_checks_enabled)`
`542`	`542`	`{`
`543`		`- if (const auto res = gate->get_module()->check_net(net, true); res.is_error())`
	`543`	`+ if (!gate->get_module()->check_net(net, true))`
`544`	`544`	`{`
`545`		`- log_error("net", "{}", res.get_error().get());`
`546`	`545`	`return nullptr;`
`547`	`546`	`}`
`548`	`547`
`549`	`548`	`for (Endpoint* ep : net->get_destinations())`
`550`	`549`	`{`
`551`		`- if (const auto res = ep->get_gate()->get_module()->check_net(net, true); res.is_error())`
	`550`	`+ if (!ep->get_gate()->get_module()->check_net(net, true))`
`552`	`551`	`{`
`553`		`- log_error("net", "{}", res.get_error().get());`
`554`	`552`	`return nullptr;`
`555`	`553`	`}`
`556`	`554`	`}`
`@@ -561,7 +559,7 @@ namespace hal`
`561`	`559`	`return new_endpoint_raw;`
`562`	`560`	`}`
`563`	`561`
`564`		`- bool NetlistInternalManager::net_remove_source(Net* net, Endpoint* ep)`
	`562`	`+ bool NetlistInternalManager::net_remove_source_internal(Net* net, Endpoint* ep)`
`565`	`563`	`{`
`566`	`564`	`auto gate = ep->get_gate();`
`567`	`565`
`@@ -570,7 +568,6 @@ namespace hal`
`570`	`568`	`return false;`
`571`	`569`	`}`
`572`	`570`
`573`		`- bool removed = false;`
`574`	`571`	`for (u32 i = 0; i < net->m_sources.size(); ++i)`
`575`	`572`	`{`
`576`	`573`	`if (net->m_sources_raw[i] == ep)`
`@@ -582,12 +579,18 @@ namespace hal`
`582`	`579`	`net->m_sources_raw[i] = net->m_sources_raw.back();`
`583`	`580`	`net->m_sources_raw.pop_back();`
`584`	`581`	`m_event_handler->notify(NetEvent::event::src_removed, net, gate->get_id());`
`585`		`- removed = true;`
`586`		`- break;`
	`582`	`+ return true;`
`587`	`583`	`}`
`588`	`584`	`}`
`589`	`585`
`590`		`- if (!removed)`
	`586`	`+ return false;`
	`587`	`+ }`
	`588`	`+`
	`589`	`+ bool NetlistInternalManager::net_remove_source(Net* net, Endpoint* ep)`
	`590`	`+ {`
	`591`	`+ auto gate = ep->get_gate();`
	`592`	`+`
	`593`	`+ if (!net_remove_source_internal(net, ep))`
`591`	`594`	`{`
`592`	`595`	`log_warning("net",`
`593`	`596`	`"output pin '{}' of gate '{}' with ID {} is not a source of net '{}' with ID {} in netlist with ID {}",`
`@@ -603,17 +606,15 @@ namespace hal`
`603`	`606`	`// update internal nets and port nets`
`604`	`607`	`if (m_net_checks_enabled)`
`605`	`608`	`{`
`606`		`- if (const auto res = gate->get_module()->check_net(net, true); res.is_error())`
	`609`	`+ if (!gate->get_module()->check_net(net, true))`
`607`	`610`	`{`
`608`		`- log_error("net", "{}", res.get_error().get());`
`609`	`611`	`return false;`
`610`	`612`	`}`
`611`	`613`
`612`	`614`	`for (Endpoint* dst : net->get_destinations())`
`613`	`615`	`{`
`614`		`- if (const auto res = dst->get_gate()->get_module()->check_net(net, true); res.is_error())`
	`616`	`+ if (!dst->get_gate()->get_module()->check_net(net, true))`
`615`	`617`	`{`
`616`		`- log_error("net", "{}", res.get_error().get());`
`617`	`618`	`return false;`
`618`	`619`	`}`
`619`	`620`	`}`
`@@ -678,17 +679,15 @@ namespace hal`
`678`	`679`	`// update internal nets and port nets`
`679`	`680`	`if (m_net_checks_enabled)`
`680`	`681`	`{`
`681`		`- if (const auto res = gate->get_module()->check_net(net, true); res.is_error())`
	`682`	`+ if (!gate->get_module()->check_net(net, true))`
`682`	`683`	`{`
`683`		`- log_error("net", "{}", res.get_error().get());`
`684`	`684`	`return nullptr;`
`685`	`685`	`}`
`686`	`686`
`687`	`687`	`for (Endpoint* ep : net->get_sources())`
`688`	`688`	`{`
`689`		`- if (const auto res = ep->get_gate()->get_module()->check_net(net, true); res.is_error())`
	`689`	`+ if (!ep->get_gate()->get_module()->check_net(net, true))`
`690`	`690`	`{`
`691`		`- log_error("net", "{}", res.get_error().get());`
`692`	`691`	`return nullptr;`
`693`	`692`	`}`
`694`	`693`	`}`
`@@ -699,15 +698,15 @@ namespace hal`
`699`	`698`	`return new_endpoint_raw;`
`700`	`699`	`}`
`701`	`700`
`702`		`- bool NetlistInternalManager::net_remove_destination(Net* net, Endpoint* ep)`
	`701`	`+ bool NetlistInternalManager::net_remove_destination_internal(Net* net, Endpoint* ep)`
`703`	`702`	`{`
`704`	`703`	`auto gate = ep->get_gate();`
	`704`	`+`
`705`	`705`	`if (!m_netlist->is_net_in_netlist(net) \|\| !m_netlist->is_gate_in_netlist(gate) \|\| !net->is_a_destination(ep))`
`706`	`706`	`{`
`707`	`707`	`return false;`
`708`	`708`	`}`
`709`	`709`
`710`		`- bool removed = false;`
`711`	`710`	`for (u32 i = 0; i < net->m_destinations.size(); ++i)`
`712`	`711`	`{`
`713`	`712`	`if (net->m_destinations_raw[i] == ep)`
`@@ -719,12 +718,18 @@ namespace hal`
`719`	`718`	`net->m_destinations_raw[i] = net->m_destinations_raw.back();`
`720`	`719`	`net->m_destinations_raw.pop_back();`
`721`	`720`	`m_event_handler->notify(NetEvent::event::dst_removed, net, gate->get_id());`
`722`		`- removed = true;`
`723`		`- break;`
	`721`	`+ return true;`
`724`	`722`	`}`
`725`	`723`	`}`
`726`	`724`
`727`		`- if (!removed)`
	`725`	`+ return false;`
	`726`	`+ }`
	`727`	`+`
	`728`	`+ bool NetlistInternalManager::net_remove_destination(Net* net, Endpoint* ep)`
	`729`	`+ {`
	`730`	`+ auto gate = ep->get_gate();`
	`731`	`+`
	`732`	`+ if (!net_remove_destination_internal(net,ep))`
`728`	`733`	`{`
`729`	`734`	`log_warning("net",`
`730`	`735`	`"input pin '{}' of gate '{}' with ID {} is not a destination of net '{}' with ID {} in netlist with ID {}",`
`@@ -739,17 +744,15 @@ namespace hal`
`739`	`744`	`{ // update internal nets and port nets`
`740`	`745`	`if (m_net_checks_enabled)`
`741`	`746`	`{`
`742`		`- if (const auto res = gate->get_module()->check_net(net, true); res.is_error())`
	`747`	`+ if (!gate->get_module()->check_net(net, true))`
`743`	`748`	`{`
`744`		`- log_error("net", "{}", res.get_error().get());`
`745`	`749`	`return false;`
`746`	`750`	`}`
`747`	`751`
`748`	`752`	`for (Endpoint* src : net->get_sources())`
`749`	`753`	`{`
`750`		`- if (const auto res = src->get_gate()->get_module()->check_net(net, true); res.is_error())`
	`754`	`+ if (!src->get_gate()->get_module()->check_net(net, true))`
`751`	`755`	`{`
`752`		`- log_error("net", "{}", res.get_error().get());`
`753`	`756`	`return false;`
`754`	`757`	`}`
`755`	`758`	`}`
`@@ -977,9 +980,8 @@ namespace hal`
`977`	`980`	`{`
`978`	`981`	`for (Net* net : nets)`
`979`	`982`	`{`
`980`		`- if (const auto res = affected_module->check_net(net, true); res.is_error())`
	`983`	`+ if (!affected_module->check_net(net, true))`
`981`	`984`	`{`
`982`		`- log_error("module", "{}", res.get_error().get());`
`983`	`985`	`return false;`
`984`	`986`	`}`
`985`	`987`	`}`
`@@ -997,11 +999,7 @@ namespace hal`
`997`	`999`
`998`	`1000`	`bool NetlistInternalManager::module_check_net(Module* module, Net* net, bool recursive)`
`999`	`1001`	`{`
`1000`		`- if (const auto res = module->check_net(net, recursive); res.is_error())`
`1001`		`- {`
`1002`		`- return false;`
`1003`		`- }`
`1004`		`- return true;`
	`1002`	`+ return module->check_net(net, recursive);`
`1005`	`1003`	`}`
`1006`	`1004`
`1007`	`1005`	`//######################################################################`