pyVHDLModelTreesitter 0.6.0__tar.gz → 0.7.0__tar.gz

{pyvhdlmodeltreesitter-0.6.0 → pyvhdlmodeltreesitter-0.7.0}/.gitignore

@@ -1,6 +1,8 @@
 /.coverage*
 /.htmlcov/
 /.junit.xml
+/.opencode/node_modules/
+/.opencode/package*.json
 /.token
 /.venv
 /dist/

{pyvhdlmodeltreesitter-0.6.0 → pyvhdlmodeltreesitter-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyVHDLModelTreesitter
-Version: 0.6.0
+Version: 0.7.0
 Summary: An implementation of pyVHDLModel using treesitter
 Project-URL: Repository, https://gitlab.com/dawalters/pyVHDLModelTreesitter
 Author: Dominic Adam Walters

{pyvhdlmodeltreesitter-0.6.0 → pyvhdlmodeltreesitter-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "pyVHDLModelTreesitter"
-version = "0.6.0"
+version = "0.7.0"
 description = "An implementation of pyVHDLModel using treesitter"
 readme = "README.md"
 requires-python = ">=3.11"
@@ -49,6 +49,9 @@ dev = [
     "uv == 0.11.26",
 ]
 
+[project.scripts]
+dump-treesitter-parse = "pyVHDLModelTreesitter.cli._dump_treesitter_parse:main"
+
 [project.urls]
 Repository = "https://gitlab.com/dawalters/pyVHDLModelTreesitter"
 
@@ -102,6 +105,7 @@ testpaths = [
 
 [tool.ruff]
 unsafe-fixes = true
+exclude = ["tests/examples/oss/open-logic"]
 
 [tool.ruff.lint]
 fixable = ["ALL"]

{pyvhdlmodeltreesitter-0.6.0 → pyvhdlmodeltreesitter-0.7.0}/src/pyVHDLModelTreesitter/Base.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 __all__ = [
     "Range",
+    "WaveformElement",
 ]
 
 from typing import TYPE_CHECKING, Self
 
 import pyVHDLModel
+from pyVHDLModel.Base import WaveformElement as VHDLModel_WaveformElement
 
 if TYPE_CHECKING:
     from tree_sitter import Node
@@ -159,3 +161,45 @@ class Range(TreesitterNodeMixin, pyVHDLModel.Base.Range):  # ruff: ignore[undocu
             f"_direction={self._direction!r}, "
             ")"
         )
+
+
+class WaveformElement(TreesitterNodeMixin, VHDLModel_WaveformElement):  # ruff: ignore[undocumented-public-class]
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: Node,
+    ) -> Self | None:
+        """Create a WaveformElement from a treesitter node."""
+        if node.type != "waveform_element":
+            return None
+        simple_expression_node = None
+        for child in node.children:
+            if child.type == "simple_expression":
+                simple_expression_node = child
+                break
+        if simple_expression_node is None:
+            NotImplementedWarning.warn(
+                "waveform_element expects a 'simple_expression' child",
+                node,
+            )
+            return None
+        expression = parse_simple_expression(simple_expression_node)
+        if expression is None:
+            return None
+        return cls(expression, _treesitter_node=node)
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return self._expression == other._expression and self._after == other._after  # type: ignore[no-any-return]
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash((self._expression, self._after))
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_expression={self._expression!r}, "
+            f"_after={self._after!r}, "
+            ")"
+        )

pyvhdlmodeltreesitter-0.7.0/src/pyVHDLModelTreesitter/Concurrent.py

@@ -0,0 +1,243 @@
+"""Submodule mirroring modified aspects of pyVHDLModel.Concurrent."""
+
+from __future__ import annotations
+
+__all__ = [
+    "ComponentInstantiation",
+    "ConcurrentSimpleSignalAssignment",
+    "EntityInstantiation",
+]
+
+from typing import TYPE_CHECKING, Any, Self
+
+from pyVHDLModel.Concurrent import (
+    ComponentInstantiation as pyVHDLModel_ComponentInstantiation,
+)
+from pyVHDLModel.Concurrent import (
+    ConcurrentSimpleSignalAssignment as pyVHDLModel_ConcurrentSimpleSignalAssignment,
+)
+from pyVHDLModel.Concurrent import (
+    EntityInstantiation as pyVHDLModel_EntityInstantiation,
+)
+
+from pyVHDLModelTreesitter.Association import (
+    GenericAssociationItem,
+    PortAssociationItem,
+)
+from pyVHDLModelTreesitter.Base import WaveformElement
+from pyVHDLModelTreesitter.Name import parse_name
+from pyVHDLModelTreesitter.Symbol import (
+    ArchitectureSymbol,
+    ComponentInstantiationSymbol,
+    EntityInstantiationSymbol,
+)
+from pyVHDLModelTreesitter.treesitter import (
+    TreesitterNodeMixin,
+    get_node,
+    get_node_text,
+    get_nodes,
+)
+from pyVHDLModelTreesitter.treesitter.query import (
+    ComponentInstantiationStatement,
+)
+from pyVHDLModelTreesitter.treesitter.query import (
+    ConcurrentSimpleSignalAssignment as ConcurrentSimpleSignalAssignmentQuery,
+)
+
+if TYPE_CHECKING:
+    import tree_sitter
+
+
+def _parse_instantiation_common(
+    node: tree_sitter.Node,
+    captures: dict[str, list[tree_sitter.Node]],
+) -> tuple[str, list[Any], list[Any]]:
+    label_node = get_node(node, captures, "label")
+    label = get_node_text(label_node)
+    generic_associations = []
+    for association_node in get_nodes(node, captures, "generics", optional=True):
+        generic_associations.extend(
+            GenericAssociationItem.from_treesitter_node(association_node),
+        )
+    port_associations = []
+    for association_node in get_nodes(node, captures, "ports", optional=True):
+        port_associations.extend(
+            PortAssociationItem.from_treesitter_node(association_node),
+        )
+    return label, generic_associations, port_associations
+
+
+class ComponentInstantiation(TreesitterNodeMixin, pyVHDLModel_ComponentInstantiation):  # ruff: ignore[undocumented-public-class]
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """Create one or more `ComponentInstantiation`s from a treesitter node."""
+        captures = ComponentInstantiationStatement.capture(node)
+        label, generic_associations, port_associations = _parse_instantiation_common(
+            node,
+            captures,
+        )
+        name_node = get_node(node, captures, "component_name")
+        component_symbol = ComponentInstantiationSymbol(
+            parse_name(get_node_text(name_node)),
+        )
+        return [
+            cls(
+                label=label,
+                componentSymbol=component_symbol,
+                genericAssociations=generic_associations,
+                portAssociations=port_associations,
+                _treesitter_node=node,
+            ),
+        ]
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._label == other._label
+            and self._component == other._component
+            and self._genericAssociations == other._genericAssociations
+            and self._portAssociations == other._portAssociations
+        )
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash(
+            (
+                self._label,
+                self._component,
+                self._genericAssociations,
+                self._portAssociations,
+            ),
+        )
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_label={self._label!r}, "
+            f"_component={self._component!r}, "
+            f"_genericAssociations={self._genericAssociations!r}, "
+            f"_portAssociations={self._portAssociations!r}, "
+            ")"
+        )
+
+
+class EntityInstantiation(TreesitterNodeMixin, pyVHDLModel_EntityInstantiation):  # ruff: ignore[undocumented-public-class]
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """Create one or more `EntityInstantiation`s from a treesitter node."""
+        captures = ComponentInstantiationStatement.capture(node)
+        label, generic_associations, port_associations = _parse_instantiation_common(
+            node,
+            captures,
+        )
+        entity_str = ""
+        namespace_node = get_node(node, captures, "namespace", optional=True)
+        if namespace_node is not None:
+            entity_str = f"{get_node_text(namespace_node)}."
+        entity_node = get_node(node, captures, "entity")
+        entity_str += get_node_text(entity_node)
+        entity_symbol = EntityInstantiationSymbol(
+            parse_name(entity_str),
+        )
+        architecture_node = get_node(node, captures, "architecture", optional=True)
+        architecture_symbol = None
+        if architecture_node is not None:
+            architecture_symbol = ArchitectureSymbol(
+                parse_name(get_node_text(architecture_node)),
+            )
+        return [
+            cls(
+                label=label,
+                entitySymbol=entity_symbol,
+                architectureSymbol=architecture_symbol,
+                genericAssociations=generic_associations,
+                portAssociations=port_associations,
+                _treesitter_node=node,
+            ),
+        ]
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._label == other._label
+            and self._entity == other._entity
+            and self._architecture == other._architecture
+            and self._genericAssociations == other._genericAssociations
+            and self._portAssociations == other._portAssociations
+        )
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash(
+            (
+                self._label,
+                self._entity,
+                self._architecture,
+                self._genericAssociations,
+                self._portAssociations,
+            ),
+        )
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_label={self._label!r}, "
+            f"_entity={self._entity!r}, "
+            f"_architecture={self._architecture!r}, "
+            f"_genericAssociations={self._genericAssociations!r}, "
+            f"_portAssociations={self._portAssociations!r}, "
+            ")"
+        )
+
+
+class ConcurrentSimpleSignalAssignment(  # ruff: ignore[undocumented-public-class]
+    TreesitterNodeMixin,
+    pyVHDLModel_ConcurrentSimpleSignalAssignment,
+):
+    @classmethod
+    def from_treesitter_node(
+        cls,
+        node: tree_sitter.Node,
+    ) -> list[Self]:
+        """Create ConcurrentSimpleSignalAssignments from a treesitter node."""
+        captures = ConcurrentSimpleSignalAssignmentQuery.capture(node)
+        label_node = get_node(node, captures, "label", optional=True)
+        label = get_node_text(label_node) if label_node is not None else ""
+        target_node = get_node(node, captures, "lhs")
+        target = parse_name(get_node_text(target_node))
+        waveform_node = get_node(node, captures, "rhs")
+        waveform = [
+            we
+            for child in waveform_node.children
+            if child.type == "waveform_element"
+            for we in [WaveformElement.from_treesitter_node(child)]
+            if we is not None
+        ]
+        return [cls(label, target, waveform, _treesitter_node=node)]
+
+    def __eq__(self, other: object) -> bool:  # ruff: ignore[undocumented-magic-method]
+        if not isinstance(other, self.__class__):
+            return False
+        return (
+            self._label == other._label
+            and self._target == other._target
+            and self._waveform == other._waveform
+        )
+
+    def __hash__(self) -> int:  # ruff: ignore[undocumented-magic-method]
+        return hash((self._label, self._target, tuple(self._waveform)))
+
+    def __repr__(self) -> str:  # ruff: ignore[undocumented-magic-method]
+        return (
+            f"{self.__class__.__name__}("
+            f"_label={self._label!r}, "
+            f"_target={self._target!r}, "
+            f"_waveform={self._waveform!r}, "
+            ")"
+        )

{pyvhdlmodeltreesitter-0.6.0 → pyvhdlmodeltreesitter-0.7.0}/src/pyVHDLModelTreesitter/DesignUnit.py

@@ -24,13 +24,17 @@ from pyVHDLModelTreesitter._errors import (
     NodeExtraChildError,
     NotImplementedWarning,
 )
-from pyVHDLModelTreesitter.Concurrent import EntityInstantiation
+from pyVHDLModelTreesitter.Concurrent import (
+    ComponentInstantiation,
+    ConcurrentSimpleSignalAssignment,
+    EntityInstantiation,
+)
 from pyVHDLModelTreesitter.Interface import (
     GenericConstantInterfaceItem,
     PortSignalInterfaceItem,
 )
 from pyVHDLModelTreesitter.Name import SimpleName, parse_name
-from pyVHDLModelTreesitter.Object import Constant
+from pyVHDLModelTreesitter.Object import Constant, Signal
 from pyVHDLModelTreesitter.Symbol import (
     EntitySymbol,
     LibraryReferenceSymbol,
@@ -137,14 +141,16 @@ class UseClause(TreesitterNodeMixin, VHDLModel_UseClause):  # ruff: ignore[undoc
         return f"{self.__class__.__name__}(_symbols={self._symbols!r}, )"
 
 
-Declarations = Constant
+Declarations = Constant | Signal
 
 
 def parse_declarations(node: tree_sitter.Node) -> list[Declarations]:
-    ret = []
+    ret: list[Declarations] = []
     for child in node.children:
         if child.type == "constant_declaration":
             ret.extend(Constant.from_treesitter_node(child))
+        elif child.type == "signal_declaration":
+            ret.extend(Signal.from_treesitter_node(child))
         elif child.type == "is":
             continue
         else:
@@ -152,6 +158,18 @@ def parse_declarations(node: tree_sitter.Node) -> list[Declarations]:
     return ret
 
 
+def _is_component_instantiation(node: tree_sitter.Node) -> bool:
+    """Check if a component_instantiation_statement is a component instantiation."""
+    if node.child_by_field_name("component") is not None:
+        return True
+    for child in node.children:
+        if child.type != "instantiated_unit":
+            continue
+        if child.child_by_field_name("component") is not None:
+            return True
+    return False
+
+
 class Architecture(TreesitterNodeMixin, VHDLModel_Architecture):  # ruff: ignore[undocumented-public-class]
     @classmethod
     def from_treesitter_node(
@@ -169,11 +187,22 @@ class Architecture(TreesitterNodeMixin, VHDLModel_Architecture):  # ruff: ignore
         declarations_node = get_node(node, captures, "declarations")
         declared_items = parse_declarations(declarations_node)
         statements_node = get_node(node, captures, "statements")
-        statements = []
+        statements: list[Any] = []
         for statement_node in statements_node.children:
             if statement_node.type == "component_instantiation_statement":
+                if _is_component_instantiation(statement_node):
+                    statements.extend(
+                        ComponentInstantiation.from_treesitter_node(statement_node),
+                    )
+                else:
+                    statements.extend(
+                        EntityInstantiation.from_treesitter_node(statement_node),
+                    )
+            elif statement_node.type == "concurrent_simple_signal_assignment":
                 statements.extend(
-                    EntityInstantiation.from_treesitter_node(statement_node),
+                    ConcurrentSimpleSignalAssignment.from_treesitter_node(
+                        statement_node,
+                    ),
                 )
             elif statement_node.type == "begin":
                 continue