Removal of custom type system

test/test_classcoverage.py

@@ -115,6 +115,7 @@
     Tanh,
     all_ufl_classes,
 )
+from ufl.core.ufl_type import UFLRegistry
 
 has_repr = set()
 has_dict = set()
@@ -722,15 +723,15 @@ def testAll(self):
     # e = action(b)
 
     # --- Check which classes have been created
-    ic, _dc = Expr.ufl_disable_profiling()
+    Expr.ufl_disable_profiling()
+    ic = UFLRegistry().object_tracking
 
     constructed = set()
-    unused = set(Expr._ufl_all_classes_)
-    for cls in Expr._ufl_all_classes_:
-        tc = cls._ufl_typecode_
-        if ic[tc]:
+    unused = set(UFLRegistry().all_classes)
+    for cls in ic.keys():
+        if ic[cls][0] > 0:
             constructed.add(cls)
-        if cls._ufl_is_abstract_:
+        else:
             unused.remove(cls)
 
     if unused:

test/test_custom_type.py

@@ -0,0 +1,54 @@
+# Copyright (C) 2025 Paul T. Kühner
+#
+# This file is part of UFL (https://www.fenicsproject.org)
+#
+# SPDX-License-Identifier:    LGPL-3.0-or-later
+#
+
+from utils import LagrangeElement
+
+from ufl import Mesh, triangle
+from ufl.algebra import Product
+from ufl.algorithms.analysis import extract_constants, has_exact_type
+from ufl.algorithms.apply_algebra_lowering import apply_algebra_lowering
+from ufl.constant import Constant
+from ufl.core.ufl_type import ufl_type
+from ufl.geometry import SpatialCoordinate
+from ufl.operators import diff
+
+
+@ufl_type()
+class LabeledConstant(Constant):
+    def __init__(self, domain, shape=(), count=None, label: str = "c"):
+        Constant.__init__(self, domain, shape, count)
+        self._label = label
+
+    @property
+    def label(self) -> str:
+        return self._label
+
+
+def test():
+    domain = Mesh(LagrangeElement(triangle, 1, (2,)))
+    a = LabeledConstant(domain, label="a")
+    b = LabeledConstant(domain, label="b")
+
+    assert a.label == "a"
+    assert b.label == "b"
+
+    ab = a * b
+    assert isinstance(ab, Product)
+    # assert ab.ufl_operands == (a, b)
+
+    assert apply_algebra_lowering(ab) == ab
+
+    x = SpatialCoordinate(domain)
+
+    a_dx = diff(a, x)
+    assert a_dx == 0
+    assert a_dx.ufl_shape == (2,)
+
+    # TODO: expression does not get simplified, so can't check here for ax_dx == a
+    ax_dx = diff(a * x, x)
+    assert has_exact_type(ax_dx, LabeledConstant)
+    assert extract_constants(ax_dx)[0].label == "a"

ufl/algebra.py

@@ -20,13 +20,7 @@
 # --- Algebraic operators ---
 
 
-@ufl_type(
-    num_ops=2,
-    inherit_shape_from_operand=0,
-    inherit_indices_from_operand=0,
-    binop="__add__",
-    rbinop="__radd__",
-)
+@ufl_type()
 class Sum(Operator):
     """Sum."""
 
@@ -103,8 +97,23 @@ def __str__(self):
         """Format as a string."""
         return " + ".join([parstr(o, self) for o in self.ufl_operands])
 
+    @property
+    def ufl_shape(self):
+        """Return shape."""
+        return self.ufl_operands[0].ufl_shape
 
-@ufl_type(num_ops=2, binop="__mul__", rbinop="__rmul__")
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
+
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions
+
+
+@ufl_type()
 class Product(Operator):
     """The product of two or more UFL objects."""
 
@@ -201,7 +210,7 @@ def __str__(self):
         return " * ".join((parstr(a, self), parstr(b, self)))
 
 
-@ufl_type(num_ops=2, inherit_indices_from_operand=0, binop="__div__", rbinop="__rdiv__")
+@ufl_type()
 class Division(Operator):
     """Division."""
 
@@ -265,8 +274,18 @@ def __str__(self):
         """Format as a string."""
         return f"{parstr(self.ufl_operands[0], self)} / {parstr(self.ufl_operands[1], self)}"
 
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
+
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions
+
 
-@ufl_type(num_ops=2, inherit_indices_from_operand=0, binop="__pow__", rbinop="__rpow__")
+@ufl_type()
 class Power(Operator):
     """Power."""
 
@@ -327,8 +346,18 @@ def __str__(self):
         a, b = self.ufl_operands
         return f"{parstr(a, self)} ** {parstr(b, self)}"
 
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
 
-@ufl_type(num_ops=1, inherit_shape_from_operand=0, inherit_indices_from_operand=0, unop="__abs__")
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions
+
+
+@ufl_type()
 class Abs(Operator):
     """Absolute value."""
 
@@ -362,8 +391,23 @@ def __str__(self):
         (a,) = self.ufl_operands
         return f"|{parstr(a, self)}|"
 
+    @property
+    def ufl_shape(self):
+        """Return shape."""
+        return self.ufl_operands[0].ufl_shape
+
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
+
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions
+
 
-@ufl_type(num_ops=1, inherit_shape_from_operand=0, inherit_indices_from_operand=0)
+@ufl_type()
 class Conj(Operator):
     """Complex conjugate."""
 
@@ -397,8 +441,23 @@ def __str__(self):
         (a,) = self.ufl_operands
         return f"conj({parstr(a, self)})"
 
+    @property
+    def ufl_shape(self):
+        """Return shape."""
+        return self.ufl_operands[0].ufl_shape
 
-@ufl_type(num_ops=1, inherit_shape_from_operand=0, inherit_indices_from_operand=0)
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
+
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions
+
+
+@ufl_type()
 class Real(Operator):
     """Real part."""
 
@@ -434,8 +493,23 @@ def __str__(self):
         (a,) = self.ufl_operands
         return f"Re[{parstr(a, self)}]"
 
+    @property
+    def ufl_shape(self):
+        """Return shape."""
+        return self.ufl_operands[0].ufl_shape
+
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
+
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions
 
-@ufl_type(num_ops=1, inherit_shape_from_operand=0, inherit_indices_from_operand=0)
+
+@ufl_type()
 class Imag(Operator):
     """Imaginary part."""
 
@@ -468,3 +542,18 @@ def __str__(self):
         """Format as a string."""
         (a,) = self.ufl_operands
         return f"Im[{parstr(a, self)}]"
+
+    @property
+    def ufl_shape(self):
+        """Return shape."""
+        return self.ufl_operands[0].ufl_shape
+
+    @property
+    def ufl_free_indices(self):
+        """Return free indices."""
+        return self.ufl_operands[0].ufl_free_indices
+
+    @property
+    def ufl_index_dimensions(self):
+        """Retrun index dimensions."""
+        return self.ufl_operands[0].ufl_index_dimensions

ufl/algorithms/apply_coefficient_split.py

@@ -105,8 +105,9 @@ def _(
         if reference_value:
             raise RuntimeError(f"Can not apply ReferenceValue on a ReferenceValue: got {o}")
         (op,) = o.ufl_operands
-        if not op._ufl_terminal_modifiers_:
-            raise ValueError(f"Must be a terminal modifier: {op!r}.")
+        # TODO: correct?
+        # if not op._ufl_is_terminal_modifier_:
+        #     raise ValueError(f"Must be a terminal modifier: {op!r}.")
         return self(
             op,
             reference_value=True,
@@ -124,8 +125,9 @@ def _(
     ) -> Expr:
         """Handle ReferenceGrad."""
         (op,) = o.ufl_operands
-        if not op._ufl_terminal_modifiers_:
-            raise ValueError(f"Must be a terminal modifier: {op!r}.")
+        # TODO:
+        # if not op._ufl_is_terminal_modifier_:
+        #     raise ValueError(f"Must be a terminal modifier: {op!r}.")
         return self(
             op,
             reference_value=reference_value,
@@ -145,8 +147,9 @@ def _(
         if restricted is not None:
             raise RuntimeError(f"Can not apply Restricted on a Restricted: got {o}")
         (op,) = o.ufl_operands
-        if not op._ufl_terminal_modifiers_:
-            raise ValueError(f"Must be a terminal modifier: {op!r}.")
+        # TODO:
+        # if not op._ufl_is_terminal_modifier_:
+        #     raise ValueError(f"Must be a terminal modifier: {op!r}.")
         return self(
             op,
             reference_value=reference_value,

ufl/algorithms/apply_derivatives.py

@@ -166,13 +166,11 @@ def __init__(
 
     def unexpected(self, o):
         """Raise error about unexpected type."""
-        raise ValueError(f"Unexpected type {o._ufl_class_.__name__} in AD rules.")
+        raise ValueError(f"Unexpected type {type(o).__name__} in AD rules.")
 
     def override(self, o):
         """Raise error about overriding."""
-        raise ValueError(
-            f"Type {o._ufl_class_.__name__} must be overridden in specialized AD rule set."
-        )
+        raise ValueError(f"Type {type(o).__name__} must be overridden in specialized AD rule set.")
 
     # --- Some types just don't have any derivative, this is just to
     # --- make algorithm structure generic
@@ -214,16 +212,15 @@ def process(self, o: Expr) -> Expr:
     def _(self, o: Expr) -> Expr:
         """Raise error."""
         raise ValueError(
-            f"Missing differentiation handler for type {o._ufl_class_.__name__}. "
+            f"Missing differentiation handler for type {type(o).__name__}. "
             "Have you added a new type?"
         )
 
     @process.register(Derivative)
     def _(self, o: Expr) -> Expr:
         """Raise error."""
         raise ValueError(
-            f"Unhandled derivative type {o._ufl_class_.__name__}, "
-            "nested differentiation has failed."
+            f"Unhandled derivative type {type(o).__name__}, nested differentiation has failed."
         )
 
     @process.register(Label)
@@ -321,7 +318,7 @@ def _(self, o: Expr) -> Expr:
 
     @process.register(Indexed)
     @DAGTraverser.postorder
-    def _(self, o: Indexed, Ap: Expr, ii: MultiIndex) -> Expr:
+    def _(self, o: Indexed, Ap: Expr, ii: MultiIndex) -> Indexed:
         """Differentiate an indexed."""
         # Propagate zeros
         if isinstance(Ap, Zero):
@@ -905,8 +902,8 @@ def _(self, o: Expr) -> Expr:
             if not f._ufl_is_in_reference_frame_:
                 raise RuntimeError("Expecting a reference frame type")
             while not f._ufl_is_terminal_:
-                (f,) = f.ufl_operands
-            element = f.ufl_function_space().ufl_element()
+                (f,) = f.ufl_operands  # type: ignore
+            element = f.ufl_function_space().ufl_element()  # type: ignore
             if element.num_sub_elements != len(domain):
                 raise RuntimeError(f"{element.num_sub_elements} != {len(domain)}")
             # Get monolithic representation of rgrad(o); o might live in a mixed space.

ufl/algorithms/apply_geometry_lowering.py

@@ -43,6 +43,7 @@
 )
 from ufl.compound_expressions import cross_expr, determinant_expr, inverse_expr
 from ufl.core.multiindex import Index, indices
+from ufl.core.ufl_type import UFLRegistry
 from ufl.corealg.map_dag import map_expr_dag
 from ufl.corealg.multifunction import MultiFunction, memoized_handler
 from ufl.domain import extract_unique_domain
@@ -58,7 +59,7 @@ def __init__(self, preserve_types=()):
         """Initialise."""
         MultiFunction.__init__(self)
         # Store preserve_types as boolean lookup table
-        self._preserve_types = [False] * Expr._ufl_num_typecodes_
+        self._preserve_types = [False] * UFLRegistry().number_registered_classes
         for cls in preserve_types:
             self._preserve_types[cls._ufl_typecode_] = True