Make deprecation transitive

Author: pavel-kirienko

pydsdl/_serializable/_array.py

@@ -25,6 +25,10 @@ def __init__(self, element_type: SerializableType, capacity: int):
         if not self.element_type.is_valid_aggregate(self):
             raise AggregationError("Specified element type of %r is not valid" % str(self))
 
+    @property
+    def deprecated(self) -> bool:
+        return self.element_type.deprecated
+
     def is_valid_aggregate(self, aggregate: SerializableType) -> bool:
         # At the moment, arrays of arrays are not allowed, but this is ensured by the grammar definition.
         # This restriction will be lifted eventually. All that needs to be done is to update the grammar only.

pydsdl/_serializable/_composite.py

@@ -39,7 +39,7 @@ class MalformedUnionError(TypeParameterError):
     pass
 
 
-class DeprecatedDependencyError(TypeParameterError):
+class DeprecatedDependencyError(AggregationError):
     pass
 
 
@@ -81,10 +81,8 @@ def __init__(  # pylint: disable=too-many-arguments
         # Name check
         if not self._name:
             raise InvalidNameError("Composite type name cannot be empty")
-
         if self.NAME_COMPONENT_SEPARATOR not in self._name:
             raise InvalidNameError("Root namespace is not specified")
-
         if len(self._name) > self.MAX_NAME_LENGTH:
             # TODO
             # Notice that per the Specification, service request/response types are unnamed,
@@ -95,7 +93,6 @@ def __init__(  # pylint: disable=too-many-arguments
             raise InvalidNameError(
                 "Name is too long: %r is longer than %d characters" % (self._name, self.MAX_NAME_LENGTH)
             )
-
         for component in self._name.split(self.NAME_COMPONENT_SEPARATOR):
             check_name(component)
 
@@ -105,7 +102,6 @@ def __init__(  # pylint: disable=too-many-arguments
             and (0 <= self._version.minor <= self.MAX_VERSION_NUMBER)
             and ((self._version.major + self._version.minor) > 0)
         )
-
         if not version_valid:
             raise InvalidVersionError("Invalid version numbers: %s.%s" % (self._version.major, self._version.minor))
 
@@ -132,14 +128,14 @@ def __init__(  # pylint: disable=too-many-arguments
         # A deprecated type can be dependent on anything.
         if not self.deprecated:
             for a in self._attributes:
-                t = a.data_type
-                if isinstance(t, CompositeType):
-                    if t.deprecated:
-                        raise DeprecatedDependencyError(
-                            "A type cannot depend on deprecated types unless it is also deprecated."
-                        )
-
-        # Aggregation check. For example, types like utf8 and byte cannot be used outside of arrays.
+                if a.data_type.deprecated:
+                    raise DeprecatedDependencyError(
+                        "A type cannot depend on deprecated types unless it is also deprecated."
+                    )
+
+        # Aggregation check. For example:
+        #   - Types like utf8 and byte cannot be used outside of arrays.
+        #   - A non-deprecated type cannot depend on a deprecated type.
         for a in self._attributes:
             if not a.data_type.is_valid_aggregate(self):
                 raise AggregationError("Type of %r is not a valid field type for %s" % (str(a), self))
@@ -201,11 +197,15 @@ def bit_length_set(self) -> BitLengthSet:
         raise NotImplementedError
 
     def is_valid_aggregate(self, aggregate: SerializableType) -> bool:
+        if self.deprecated:  # Deprecation consistency check: non-deprecated cannot depend on a deprecated type.
+            if isinstance(aggregate, CompositeType) and not aggregate.deprecated:
+                return False
+
         return True
 
     @property
     def deprecated(self) -> bool:
-        """Whether the definition is marked ``@deprecated``."""
+        """True if the definition is marked ``@deprecated``."""
         return self._deprecated
 
     @property
@@ -615,6 +615,9 @@ def iterate_fields_with_offsets(
         base_offset = base_offset + self.delimiter_header_type.bit_length_set
         return self.inner_type.iterate_fields_with_offsets(base_offset)
 
+    def is_valid_aggregate(self, aggregate: SerializableType) -> bool:
+        return self.inner_type.is_valid_aggregate(aggregate)
+
     def __repr__(self) -> str:
         return "%s(inner=%r, extent=%r)" % (self.__class__.__name__, self.inner_type, self.extent)
 

pydsdl/_serializable/_primitive.py

@@ -51,6 +51,11 @@ def __init__(self, bit_length: int, cast_mode: "PrimitiveType.CastMode"):
     def bit_length_set(self) -> BitLengthSet:
         return BitLengthSet(self.bit_length)
 
+    @property
+    def deprecated(self) -> bool:
+        """Primitive types cannot be deprecated."""
+        return False
+
     def is_valid_aggregate(self, aggregate: SerializableType) -> bool:
         return True
 

pydsdl/_serializable/_serializable.py

@@ -60,6 +60,15 @@ def alignment_requirement(self) -> int:
         """
         raise NotImplementedError
 
+    @property
+    @abc.abstractmethod
+    def deprecated(self) -> bool:
+        """
+        Deprecation is transitive.
+        This property is used to propagate deprecation information from the type to its aggregates.
+        """
+        raise NotImplementedError
+
     @abc.abstractmethod
     def is_valid_aggregate(self, aggregate: "SerializableType") -> bool:
         """

pydsdl/_serializable/_void.py

@@ -24,10 +24,15 @@ def __init__(self, bit_length: int):
     def bit_length_set(self) -> BitLengthSet:
         return BitLengthSet(self.bit_length)
 
+    @property
+    def deprecated(self) -> bool:
+        """Void types cannot be deprecated."""
+        return False
+
     def is_valid_aggregate(self, aggregate: SerializableType) -> bool:
         from ._composite import StructureType, CompositeType
 
-        # Unions are not allowed to contain void types.
+        # Unions are not allowed to contain void types. Only StructureType is allowed to do so.
         return isinstance(aggregate, CompositeType) and isinstance(aggregate.inner_type, StructureType)
 
     @property

pydsdl/_test.py

@@ -1710,6 +1710,20 @@ def _unittest_inconsistent_deprecation(wrkspc: Workspace) -> None:
             [wrkspc.parse_new("ns/X.1.0.dsdl", "@deprecated\n@sealed")],
         )
 
+    with raises(_error.InvalidDefinitionError, match="(?i).*depend.*deprecated.*"):
+        parse_definition(
+            wrkspc.parse_new(
+                "ns/C.1.0.dsdl",
+                dedent(
+                    """
+                X.1.0[<9] b  # Ensure the deprecation property is transitive.
+                @sealed
+                """
+                ),
+            ),
+            [wrkspc.parse_new("ns/X.1.0.dsdl", "@deprecated\n@sealed")],
+        )
+
     parse_definition(
         wrkspc.parse_new(
             "ns/D.1.0.dsdl",