Mangle function names with their node id due to spec ambiguity about name uniqueness.

Author: zrho

hugr-py/src/hugr/model/export.py

@@ -95,7 +95,8 @@ def export_node(self, node: Node) -> Optional[model.Node]:
                 )
 
             case FuncDefn() as op:
-                symbol = self.export_symbol(op.f_name, op.signature.params, op.signature.body)
+                name = _mangle_name(node, op.f_name)
+                symbol = self.export_symbol(name, op.signature.params, op.signature.body)
                 region = self.export_region_dfg(node)
 
                 return model.Node(
@@ -104,7 +105,8 @@ def export_node(self, node: Node) -> Optional[model.Node]:
                 )
 
             case FuncDecl() as op:
-                symbol = self.export_symbol(op.f_name, op.signature.params, op.signature.body)
+                name = _mangle_name(node, op.f_name)
+                symbol = self.export_symbol(name, op.signature.params, op.signature.body)
                 return model.Node(
                     operation = model.DeclareFunc(symbol),
                 )
@@ -399,16 +401,16 @@ def export_symbol(
         params = []
 
         for i, param_type in enumerate(param_types):
-            name = str(i)
+            param_name = str(i)
 
             params.append(model.Param(
-                name = name,
+                name = param_name,
                 type = param_type.to_model()
             ))
 
             match param_type:
                 case TypeTypeParam(bound = TypeBound.Copyable):
-                    constraints.append(model.Apply("core.nonlinear", [model.Var(name)]))
+                    constraints.append(model.Apply("core.nonlinear", [model.Var(param_name)]))
                 case _:
                     pass
 
@@ -432,12 +434,14 @@ def find_func_input(self, node: Node) -> Optional[str]:
 
         match self.hugr[func_node].op:
             case FuncDecl() as func_op:
-                return func_op.f_name
+                name = func_op.f_name
             case FuncDefn() as func_op:
-                return func_op.f_name
+                name = func_op.f_name
             case _:
                 return None
 
+        return _mangle_name(node, name)
+
     def find_const_input(self, node: Node) -> Optional[model.Term]:
         try:
             const_node = next(
@@ -455,6 +459,11 @@ def find_const_input(self, node: Node) -> Optional[model.Term]:
             case op:
                 return None
 
+def _mangle_name(node: Node, name: str) -> str:
+    # Until we come to an agreement on the uniqueness of names, we mangle the names
+    # by adding the node id.
+    return f"_{name}_{node.idx}"
+
 class UnionFind[T]:
     def __init__(self):
         self.parents: dict[T, T] = {}
@@ -486,8 +495,3 @@ def union(self, a: T, b: T):
 
         self.parents[b] = a
         self.sizes[a] += self.sizes[b]
-
-
-# def find_static_input(hugr: Hugr, node: Node) -> Optional[Node]:
-#     for (in_port, out_ports) in hugr.incoming_links(node):
-#         if hugr.port_kind(in_port) == Function