Backend formatter interface (#806)

* Dispatch in formatters

* Lock down interface on formatter for single capability

* Dispatch on __call__

* More

* Missed one

* implementation.py -> formatter.py

* Add ABC as interface of Formatter

* Fix import

* one more

* Apply suggestions from code review

Co-authored-by: Jørgen Schartum Dokken <dokken@simula.no>

* Fixup syntax

* StatementList as in C formatter

---------

Co-authored-by: Jørgen Schartum Dokken <dokken@simula.no>

Author: schnellerhase

ffcx/codegeneration/C/__init__.py

@@ -2,4 +2,6 @@
 
 from ffcx.codegeneration.C import expressions, file, form, integrals
 
-__all__ = ["expressions", "file", "form", "integrals", "suffixes"]
+from .formatter import Formatter
+
+__all__ = ["Formatter", "expressions", "file", "form", "integrals", "suffixes"]

ffcx/codegeneration/C/expressions.py

@@ -14,7 +14,7 @@
 
 from ffcx.codegeneration.backend import FFCXBackend
 from ffcx.codegeneration.C import expressions_template
-from ffcx.codegeneration.C.implementation import Formatter
+from ffcx.codegeneration.C.formatter import Formatter
 from ffcx.codegeneration.expression_generator import ExpressionGenerator
 from ffcx.codegeneration.utils import dtype_to_c_type, dtype_to_scalar_dtype
 from ffcx.ir.representation import ExpressionIR
@@ -44,8 +44,8 @@ def generator(ir: ExpressionIR, options):
     d["factory_name"] = factory_name
     parts = eg.generate()
 
-    CF = Formatter(options["scalar_type"])
-    d["tabulate_expression"] = CF.format(parts)
+    format = Formatter(options["scalar_type"])
+    d["tabulate_expression"] = format(parts)
 
     if len(ir.original_coefficient_positions) > 0:
         d["original_coefficient_positions"] = f"original_coefficient_positions_{factory_name}"

ffcx/codegeneration/C/implementation.py ffcx/codegeneration/C/formatter.pyffcx/codegeneration/C/implementation.py renamed to ffcx/codegeneration/C/formatter.py

@@ -1,16 +1,18 @@
-# Copyright (C) 2023 Chris Richardson
+# Copyright (C) 2023-2025 Chris Richardson and Paul T. Kühner
 #
 # This file is part of FFCx. (https://www.fenicsproject.org)
 #
 # SPDX-License-Identifier:    LGPL-3.0-or-later
 """C implementation."""
 
 import warnings
+from functools import singledispatchmethod
 
 import numpy as np
 import numpy.typing as npt
 
 import ffcx.codegeneration.lnodes as L
+from ffcx.codegeneration.interface import Formatter as FormatterInterface
 from ffcx.codegeneration.utils import dtype_to_c_type, dtype_to_scalar_dtype
 
 math_table = {
@@ -142,7 +144,7 @@
 }
 
 
-class Formatter:
+class Formatter(FormatterInterface):
     """C formatter."""
 
     scalar_type: np.dtype
@@ -184,11 +186,18 @@ def _build_initializer_lists(self, values):
         arr += "}"
         return arr
 
-    def format_statement_list(self, slist) -> str:
+    @singledispatchmethod
+    def __call__(self, obj: L.LNode) -> str:
+        """Format an L Node."""
+        raise NotImplementedError(f"Can not format object to type {type(obj)}")
+
+    @__call__.register
+    def _(self, slist: L.StatementList) -> str:
         """Format a statement list."""
-        return "".join(self.format(s) for s in slist.statements)
+        return "".join(self(s) for s in slist.statements)
 
-    def format_section(self, section) -> str:
+    @__call__.register
+    def _(self, section: L.Section) -> str:
         """Format a section."""
         # add new line before section
         comments = (
@@ -197,28 +206,30 @@ def format_section(self, section) -> str:
             f"// Inputs: {', '.join(w.name for w in section.input)}\n"
             f"// Outputs: {', '.join(w.name for w in section.output)}\n"
         )
-        declarations = "".join(self.format(s) for s in section.declarations)
+        declarations = "".join(self(s) for s in section.declarations)
 
         body = ""
         if len(section.statements) > 0:
             declarations += "{\n  "
-            body = "".join(self.format(s) for s in section.statements)
+            body = "".join(self(s) for s in section.statements)
             body = body.replace("\n", "\n  ")
             body = body[:-2] + "}\n"
 
         body += "// ------------------------ \n"
         return str(comments + declarations + body)
 
-    def format_comment(self, c: L.Comment) -> str:
+    @__call__.register
+    def _(self, c: L.Comment) -> str:
         """Format a comment."""
-        return "// " + c.comment + "\n"
+        return f"// {c.comment}\n"
 
-    def format_array_decl(self, arr) -> str:
+    @__call__.register
+    def _(self, arr: L.ArrayDecl) -> str:
         """Format an array declaration."""
         dtype = arr.symbol.dtype
         typename = self._dtype_to_name(dtype)
 
-        symbol = self.format(arr.symbol)
+        symbol = self(arr.symbol)
         dims = "".join([f"[{i}]" for i in arr.sizes])
         if arr.values is None:
             assert arr.const is False
@@ -228,23 +239,26 @@ def format_array_decl(self, arr) -> str:
         cstr = "static const " if arr.const else ""
         return f"{cstr}{typename} {symbol}{dims} = {vals};\n"
 
-    def format_array_access(self, arr) -> str:
+    @__call__.register
+    def _(self, arr: L.ArrayAccess) -> str:
         """Format an array access."""
-        name = self.format(arr.array)
-        indices = f"[{']['.join(self.format(i) for i in arr.indices)}]"
+        name = self(arr.array)
+        indices = f"[{']['.join(self(i) for i in arr.indices)}]"
         return f"{name}{indices}"
 
-    def format_variable_decl(self, v) -> str:
+    @__call__.register
+    def _(self, v: L.VariableDecl) -> str:
         """Format a variable declaration."""
-        val = self.format(v.value)
-        symbol = self.format(v.symbol)
+        val = self(v.value)
+        symbol = self(v.symbol)
         typename = self._dtype_to_name(v.symbol.dtype)
         return f"{typename} {symbol} = {val};\n"
 
-    def format_nary_op(self, oper) -> str:
+    @__call__.register
+    def _(self, oper: L.NaryOp) -> str:
         """Format an n-ary operation."""
         # Format children
-        args = [self.format(arg) for arg in oper.args]
+        args = [self(arg) for arg in oper.args]
 
         # Apply parentheses
         for i in range(len(args)):
@@ -254,11 +268,12 @@ def format_nary_op(self, oper) -> str:
         # Return combined string
         return f" {oper.op} ".join(args)
 
-    def format_binary_op(self, oper) -> str:
+    @__call__.register
+    def _(self, oper: L.BinOp) -> str:
         """Format a binary operation."""
         # Format children
-        lhs = self.format(oper.lhs)
-        rhs = self.format(oper.rhs)
+        lhs = self(oper.lhs)
+        rhs = self(oper.rhs)
 
         # Apply parentheses
         if oper.lhs.precedence >= oper.precedence:
@@ -269,52 +284,61 @@ def format_binary_op(self, oper) -> str:
         # Return combined string
         return f"{lhs} {oper.op} {rhs}"
 
-    def format_unary_op(self, oper) -> str:
+    @__call__.register(L.Neg)
+    @__call__.register(L.Not)
+    def _(self, oper: L.Neg | L.Not) -> str:
         """Format a unary operation."""
-        arg = self.format(oper.arg)
+        arg = self(oper.arg)
         if oper.arg.precedence >= oper.precedence:
             return f"{oper.op}({arg})"
         return f"{oper.op}{arg}"
 
-    def format_literal_float(self, val) -> str:
+    @__call__.register
+    def _(self, val: L.LiteralFloat) -> str:
         """Format a literal float."""
         value = self._format_number(val.value)
         return f"{value}"
 
-    def format_literal_int(self, val) -> str:
+    @__call__.register
+    def _(self, val: L.LiteralInt) -> str:
         """Format a literal int."""
         return f"{val.value}"
 
-    def format_for_range(self, r) -> str:
+    @__call__.register
+    def _(self, r: L.ForRange) -> str:
         """Format a for loop over a range."""
-        begin = self.format(r.begin)
-        end = self.format(r.end)
-        index = self.format(r.index)
+        begin = self(r.begin)
+        end = self(r.end)
+        index = self(r.index)
         output = f"for (int {index} = {begin}; {index} < {end}; ++{index})\n"
         output += "{\n"
-        body = self.format(r.body)
+        body = self(r.body)
         for line in body.split("\n"):
             if len(line) > 0:
                 output += f"  {line}\n"
         output += "}\n"
         return output
 
-    def format_statement(self, s) -> str:
+    @__call__.register
+    def _(self, s: L.Statement) -> str:
         """Format a statement."""
-        return self.format(s.expr)
+        return self(s.expr)
 
-    def format_assign(self, expr) -> str:
+    @__call__.register(L.Assign)
+    @__call__.register(L.AssignAdd)
+    def _(self, expr: L.Assign | L.AssignAdd) -> str:
         """Format an assignment."""
-        rhs = self.format(expr.rhs)
-        lhs = self.format(expr.lhs)
+        rhs = self(expr.rhs)
+        lhs = self(expr.lhs)
         return f"{lhs} {expr.op} {rhs};\n"
 
-    def format_conditional(self, s) -> str:
+    @__call__.register
+    def _(self, s: L.Conditional) -> str:
         """Format a conditional."""
         # Format children
-        c = self.format(s.condition)
-        t = self.format(s.true)
-        f = self.format(s.false)
+        c = self(s.condition)
+        t = self(s.true)
+        f = self(s.false)
 
         # Apply parentheses
         if s.condition.precedence >= s.precedence:
@@ -327,15 +351,18 @@ def format_conditional(self, s) -> str:
         # Return combined string
         return c + " ? " + t + " : " + f
 
-    def format_symbol(self, s) -> str:
+    @__call__.register
+    def _(self, s: L.Symbol) -> str:
         """Format a symbol."""
         return f"{s.name}"
 
-    def format_multi_index(self, mi) -> str:
+    @__call__.register
+    def _(self, mi: L.MultiIndex) -> str:
         """Format a multi-index."""
-        return self.format(mi.global_index)
+        return self(mi.global_index)
 
-    def format_math_function(self, c) -> str:
+    @__call__.register
+    def _(self, c: L.MathFunction) -> str:
         """Format a mathematical function."""
         # Get a table of functions for this type, if available
         arg_type = self.scalar_type
@@ -349,48 +376,5 @@ def format_math_function(self, c) -> str:
 
         # Get a function from the table, if available, else just use bare name
         func = dtype_math_table.get(c.function, c.function)
-        args = ", ".join(self.format(arg) for arg in c.args)
+        args = ", ".join(self(arg) for arg in c.args)
         return f"{func}({args})"
-
-    impl = {
-        "Section": format_section,
-        "StatementList": format_statement_list,
-        "Comment": format_comment,
-        "ArrayDecl": format_array_decl,
-        "ArrayAccess": format_array_access,
-        "MultiIndex": format_multi_index,
-        "VariableDecl": format_variable_decl,
-        "ForRange": format_for_range,
-        "Statement": format_statement,
-        "Assign": format_assign,
-        "AssignAdd": format_assign,
-        "Product": format_nary_op,
-        "Neg": format_unary_op,
-        "Sum": format_nary_op,
-        "Add": format_binary_op,
-        "Sub": format_binary_op,
-        "Mul": format_binary_op,
-        "Div": format_binary_op,
-        "Not": format_unary_op,
-        "LiteralFloat": format_literal_float,
-        "LiteralInt": format_literal_int,
-        "Symbol": format_symbol,
-        "Conditional": format_conditional,
-        "MathFunction": format_math_function,
-        "And": format_binary_op,
-        "Or": format_binary_op,
-        "NE": format_binary_op,
-        "EQ": format_binary_op,
-        "GE": format_binary_op,
-        "LE": format_binary_op,
-        "GT": format_binary_op,
-        "LT": format_binary_op,
-    }
-
-    def format(self, s) -> str:
-        """Format as C."""
-        name = s.__class__.__name__
-        try:
-            return self.impl[name](self, s)
-        except KeyError:
-            raise RuntimeError("Unknown statement: ", name)

ffcx/codegeneration/C/integrals.py

@@ -14,7 +14,7 @@
 
 from ffcx.codegeneration.backend import FFCXBackend
 from ffcx.codegeneration.C import integrals_template as ufcx_integrals
-from ffcx.codegeneration.C.implementation import Formatter
+from ffcx.codegeneration.C.formatter import Formatter
 from ffcx.codegeneration.integral_generator import IntegralGenerator
 from ffcx.codegeneration.utils import dtype_to_c_type, dtype_to_scalar_dtype
 from ffcx.ir.representation import IntegralIR
@@ -55,8 +55,8 @@ def generator(
     parts = ig.generate(domain)
 
     # Format code as string
-    CF = Formatter(options["scalar_type"])  # type: ignore
-    body = CF.format(parts)
+    format = Formatter(options["scalar_type"])  # type: ignore
+    body = format(parts)
 
     # Generate generic FFCx code snippets and add specific parts
     code = {}

ffcx/codegeneration/interface.py

@@ -0,0 +1,25 @@
+# Copyright (C) 2025 Paul T. Kühner
+#
+# This file is part of FFCx. (https://www.fenicsproject.org)
+#
+# SPDX-License-Identifier:    LGPL-3.0-or-later
+
+"""Backend interface declarations."""
+
+import abc
+
+from numpy import typing as npt
+
+import ffcx.codegeneration.lnodes as L
+
+
+class Formatter(abc.ABC):
+    """Formatter interface."""
+
+    def __init__(self, dtype: npt.DTypeLike) -> None:
+        """Create."""
+        raise NotImplementedError
+
+    def __call__(self, obj: L.LNode) -> str:
+        """Convert L-Node(s) to string representation."""
+        raise NotImplementedError

ffcx/codegeneration/numba/__init__.py

@@ -2,4 +2,6 @@
 
 from ffcx.codegeneration.numba import expressions, file, form, integrals
 
-__all__ = ["expressions", "file", "form", "integrals", "suffixes"]
+from .formatter import Formatter
+
+__all__ = ["Formatter", "expressions", "file", "form", "integrals", "suffixes"]

ffcx/codegeneration/numba/expressions.py

@@ -14,7 +14,7 @@
 from ffcx.codegeneration.backend import FFCXBackend
 from ffcx.codegeneration.expression_generator import ExpressionGenerator
 from ffcx.codegeneration.numba import expressions_template
-from ffcx.codegeneration.numba.implementation import Formatter
+from ffcx.codegeneration.numba.formatter import Formatter
 from ffcx.ir.representation import ExpressionIR
 
 logger = logging.getLogger("ffcx")
@@ -64,8 +64,8 @@ def generator(ir: ExpressionIR, options: dict[str, int | float | npt.DTypeLike])
     entity_local_index = numba.carray(_entity_local_index, ({size_local_index}))
     quadrature_permutation = numba.carray(_quadrature_permutation, ({size_permutation}))
     """
-    F = Formatter(options["scalar_type"])  # type: ignore
-    body = F.format(parts)
+    format = Formatter(options["scalar_type"])  # type: ignore
+    body = format(parts)
     body = "\n".join(["    " + line for line in body.split("\n")])
 
     d["tabulate_expression"] = header + body