Add explicit context to name_from

Author: ducky64

edg/abstract_parts/IoController.py

@@ -175,7 +175,7 @@ def _make_pinning(self) -> Dict[str, CircuitPort]:
         allocation_list.append((io_port.elt_type(), self.get(io_port.requested())))
       elif isinstance(io_port, Port):  # derive Port connections from is_connected
         if self.get(io_port.is_connected()):
-          requested = [self._name_of_child(io_port)]  # generate requested name from port name if connected
+          requested = [self._name_of_child(io_port, self)]  # generate requested name from port name if connected
         else:
           requested = []
         allocation_list.append((type(io_port), requested))

edg/core/Array.py

@@ -130,12 +130,12 @@ def items(self) -> ItemsView[str, VectorType]:
     return self._elts.items()
 
   # unlike most other LibraryElement types, the names are stored in _elts and _allocates
-  def _name_of_child(self, subelt: Any, allow_unknown: bool = False) -> str:
+  def _name_of_child(self, subelt: Any, context: Any, allow_unknown: bool = False) -> str:
     from .HierarchyBlock import Block
     block_parent = self._block_parent()
     assert isinstance(block_parent, Block)
 
-    if builder.get_enclosing_block() is block_parent or builder.get_enclosing_block() is None:
+    if context is block_parent:
       # in block defining this port (direct elt definition), or in test top
       assert self._elts is not None, "can't get name on undefined vector"
       for (name, elt) in self._elts.items():
@@ -145,7 +145,7 @@ def _name_of_child(self, subelt: Any, allow_unknown: bool = False) -> str:
         return f"(unknown {subelt.__class__.__name__})"
       else:
         raise ValueError(f"no name for {subelt}")
-    elif builder.get_enclosing_block() is block_parent._parent:
+    elif context is block_parent._parent:
       # in block enclosing the block defining this port (allocate required)
       for (i, (suggested_name, allocate_elt)) in enumerate(self._requests):
         if subelt is allocate_elt:

edg/core/Core.py

@@ -209,7 +209,7 @@ def __setattr__(self, name: str, value: Any) -> None:
       self.manager.add_element(name, value)
     super().__setattr__(name, value)
 
-  def _name_of_child(self, subelt: Any, allow_unknown: bool = False) -> str:
+  def _name_of_child(self, subelt: Any, context: Any, allow_unknown: bool = False) -> str:
     self_name = self.manager.name_of(subelt)
     if self_name is not None:
       return self_name
@@ -224,7 +224,7 @@ def _path_from(self, base: LibraryElement, allow_unknown: bool = False) -> List[
       return []
     else:
       assert self._parent is not None, "can't get path / name for non-bound element"
-      return self._parent._path_from(base, allow_unknown) + [self._parent._name_of_child(self, allow_unknown)]
+      return self._parent._path_from(base, allow_unknown) + [self._parent._name_of_child(self, base, allow_unknown)]
 
   def _name_from(self, base: LibraryElement, allow_unknown: bool = False) -> str:
     """Returns the path name to (inclusive) this element from some starting point.

edg/core/DesignTop.py

@@ -84,7 +84,7 @@ def _populate_def_proto_block_contents(self, pb: edgir.HierarchyBlock) -> edgir.
       else:
         raise TypeError
       assert isinstance(multipack_block, MultipackBlock)
-      multipack_name = self._name_of_child(multipack_block)
+      multipack_name = self._name_of_child(multipack_block, self)
       multipack_ref_base = edgir.LocalPath()
       multipack_ref_base.steps.add().name = multipack_name
       multipack_ref_map = multipack_block._get_ref_map(multipack_ref_base)
@@ -96,9 +96,9 @@ def _populate_def_proto_block_contents(self, pb: edgir.HierarchyBlock) -> edgir.
       packed_ref_map = multipack_part_block._get_ref_map(packed_ref_base)
 
       if isinstance(multipack_part, Block):
-        part_name = multipack_block._name_of_child(multipack_part)
+        part_name = multipack_block._name_of_child(multipack_part, self)
       elif isinstance(multipack_part, PackedBlockAllocate):
-        part_name = multipack_block._name_of_child(multipack_part.parent)
+        part_name = multipack_block._name_of_child(multipack_part.parent, self)
         assert multipack_part.suggested_name, "multipack parts must have suggested name, for consistency"
         part_name += f"[{multipack_part.suggested_name}]"
       else:
@@ -111,7 +111,7 @@ def _populate_def_proto_block_contents(self, pb: edgir.HierarchyBlock) -> edgir.
           packed_port_port = packed_port.port
         else:
           raise TypeError
-        packed_port_name = multipack_part_block._name_of_child(packed_port_port)
+        packed_port_name = multipack_part_block._name_of_child(packed_port_port, self)
         exported_tunnel = edgir.add_pair(pb.constraints,
                                          f"(packed){multipack_name}.{part_name}.{packed_port_name}").exportedTunnel
         exported_tunnel.internal_block_port.ref.CopyFrom(multipack_ref_map[exterior_port])
@@ -123,13 +123,13 @@ def _populate_def_proto_block_contents(self, pb: edgir.HierarchyBlock) -> edgir.
 
       for multipack_param, packed_param in packing_rule.tunnel_assigns.items():
         if isinstance(packed_param, ConstraintExpr):
-          packed_param_name = multipack_part_block._name_of_child(packed_param)
+          packed_param_name = multipack_part_block._name_of_child(packed_param, self)
           assign_tunnel = edgir.add_pair(pb.constraints,
                                          f"(packed){multipack_name}.{part_name}.{packed_param_name}").assignTunnel
           assign_tunnel.dst.CopyFrom(multipack_ref_map[multipack_param])
           assign_tunnel.src.ref.CopyFrom(packed_ref_map[packed_param])
         elif isinstance(packed_param, PackedBlockParamArray):
-          multipack_param_name = multipack_block._name_of_child(multipack_param)
+          multipack_param_name = multipack_block._name_of_child(multipack_param, self)
           constr_name = f"(packed){multipack_name}.{multipack_param_name}"
           packed_params.setdefault(constr_name, (multipack_ref_map[multipack_param], []))[1].append(
             packed_ref_map[packed_param.param])
@@ -138,14 +138,14 @@ def _populate_def_proto_block_contents(self, pb: edgir.HierarchyBlock) -> edgir.
 
       for multipack_param, unpacked_param in packing_rule.tunnel_unpack_assigns.items():
         if isinstance(unpacked_param, ConstraintExpr):
-          multipack_param_name = multipack_block._name_of_child(multipack_param)
+          multipack_param_name = multipack_block._name_of_child(multipack_param, self)
           # TODO need better constraint naming scheme
           assign_tunnel = edgir.add_pair(pb.constraints,
                                          f"(unpacked){multipack_name}.{part_name}.{multipack_param_name}").assignTunnel
           assign_tunnel.dst.CopyFrom(packed_ref_map[unpacked_param])
           assign_tunnel.src.ref.CopyFrom(multipack_ref_map[multipack_param])
         elif isinstance(unpacked_param, PackedBlockParam):
-          multipack_param_name = multipack_block._name_of_child(multipack_param)
+          multipack_param_name = multipack_block._name_of_child(multipack_param, self)
           # TODO need better constraint naming scheme
           assign_tunnel = edgir.add_pair(pb.constraints,
                                          f"(unpacked){multipack_name}.{part_name}.{multipack_param_name}").assignTunnel

edg/core/Ports.py

@@ -183,7 +183,7 @@ def _convert(self, adapter: PortAdapter[ConvertTargetType]) -> ConvertTargetType
     adapter_inst = enclosing_block.Block(adapter)
     adapter_name_suffix = f"_{self._adapter_count}" if self._adapter_count > 0 else ""
     enclosing_block.manager.add_element(
-      f"(adapter){block_parent._name_from(enclosing_block)}.{self._name_from(block_parent)}{adapter_name_suffix}",
+      f"(adapter){self._name_from(enclosing_block)}{adapter_name_suffix}",
       adapter_inst)
     enclosing_block.connect(self, adapter_inst.src)  # we don't name it to avoid explicit name conflicts
     self._adapter_count += 1