[PATCH 09/26] rv/rvgen: replace inline NotImplemented with decorator

[Wander Lairson Costa <wander@redhat.com>]

Replace inline NotImplementedError raises with a dedicated decorator in
the ltl2ba module. The previous implementation used explicit raise
statements inside abstract method bodies for BinaryOp and UnaryOp
classes, which required maintaining identical boilerplate across seven
different methods that need to be overridden by subclasses.

All stub methods in generator.py have been converted from returning
strings to using the decorator with ellipsis function bodies, which
is the recommended Python style for marking incomplete interface
methods. This ensures that any attempt to use unimplemented
functionality fails fast with a clear exception rather than silently
propagating string values through the code.

The new @not_implemented decorator consolidates this pattern into a
single reusable definition that clearly marks abstract methods while
reducing code duplication. The decorator creates a wrapper that raises
NotImplementedError with the function name, providing the same runtime
behavior with improved maintainability. Method bodies now use the
ellipsis literal instead of pass statements, which is the preferred
Python convention for stub methods according to PEP 8.

Signed-off-by: Wander Lairson Costa <wander@redhat.com>
---
 tools/verification/rvgen/rvgen/generator.py | 29 +++++++++--------
 tools/verification/rvgen/rvgen/ltl2ba.py    | 25 ++++++++------
 tools/verification/rvgen/rvgen/utils.py     | 36 +++++++++++++++++++++
 3 files changed, 66 insertions(+), 24 deletions(-)
 create mode 100644 tools/verification/rvgen/rvgen/utils.py

diff --git a/tools/verification/rvgen/rvgen/generator.py b/tools/verification/rvgen/rvgen/generator.py
index ee75e111feef1..fc9be5f6aaa1f 100644
--- a/tools/verification/rvgen/rvgen/generator.py
+++ b/tools/verification/rvgen/rvgen/generator.py
@@ -7,6 +7,7 @@
 
 import platform
 import os
+from .utils import not_implemented
 
 
 class RVGenerator:
@@ -73,14 +74,14 @@ class RVGenerator:
             return f"#include <monitors/{self.parent}/{self.parent}.h>\n"
         return ""
 
-    def fill_tracepoint_handlers_skel(self):
-        return "NotImplemented"
+    @not_implemented
+    def fill_tracepoint_handlers_skel(self): ...
 
-    def fill_tracepoint_attach_probe(self):
-        return "NotImplemented"
+    @not_implemented
+    def fill_tracepoint_attach_probe(self): ...
 
-    def fill_tracepoint_detach_helper(self):
-        return "NotImplemented"
+    @not_implemented
+    def fill_tracepoint_detach_helper(self): ...
 
     def fill_main_c(self):
         main_c = self.main_c
@@ -100,17 +101,17 @@ class RVGenerator:
 
         return main_c
 
-    def fill_model_h(self):
-        return "NotImplemented"
+    @not_implemented
+    def fill_model_h(self): ...
 
-    def fill_monitor_class_type(self):
-        return "NotImplemented"
+    @not_implemented
+    def fill_monitor_class_type(self): ...
 
-    def fill_monitor_class(self):
-        return "NotImplemented"
+    @not_implemented
+    def fill_monitor_class(self): ...
 
-    def fill_tracepoint_args_skel(self, tp_type):
-        return "NotImplemented"
+    @not_implemented
+    def fill_tracepoint_args_skel(self, tp_type): ...
 
     def fill_monitor_deps(self):
         buff = []
diff --git a/tools/verification/rvgen/rvgen/ltl2ba.py b/tools/verification/rvgen/rvgen/ltl2ba.py
index f14e6760ac3db..9a3fb7c5f4f65 100644
--- a/tools/verification/rvgen/rvgen/ltl2ba.py
+++ b/tools/verification/rvgen/rvgen/ltl2ba.py
@@ -9,6 +9,7 @@
 
 from ply.lex import lex
 from ply.yacc import yacc
+from .utils import not_implemented
 
 # Grammar:
 # 	ltl ::= opd | ( ltl ) | ltl binop ltl | unop ltl
@@ -150,14 +151,14 @@ class BinaryOp:
         yield from self.left
         yield from self.right
 
-    def normalize(self):
-        raise NotImplementedError
+    @not_implemented
+    def normalize(self): ...
 
-    def negate(self):
-        raise NotImplementedError
+    @not_implemented
+    def negate(self): ...
 
-    def _is_temporal(self):
-        raise NotImplementedError
+    @not_implemented
+    def _is_temporal(self): ...
 
     def is_temporal(self):
         if self.left.op.is_temporal():
@@ -167,8 +168,9 @@ class BinaryOp:
         return self._is_temporal()
 
     @staticmethod
+    @not_implemented
     def expand(n: ASTNode, node: GraphNode, node_set) -> set[GraphNode]:
-        raise NotImplementedError
+        ...
 
 class AndOp(BinaryOp):
     op_str = '&&'
@@ -288,19 +290,22 @@ class UnaryOp:
     def __hash__(self):
         return hash(self.child)
 
+    @not_implemented
     def normalize(self):
-        raise NotImplementedError
+        ...
 
+    @not_implemented
     def _is_temporal(self):
-        raise NotImplementedError
+        ...
 
     def is_temporal(self):
         if self.child.op.is_temporal():
             return True
         return self._is_temporal()
 
+    @not_implemented
     def negate(self):
-        raise NotImplementedError
+        ...
 
 class EventuallyOp(UnaryOp):
     def __str__(self):
diff --git a/tools/verification/rvgen/rvgen/utils.py b/tools/verification/rvgen/rvgen/utils.py
new file mode 100644
index 0000000000000..e09c943693edf
--- /dev/null
+++ b/tools/verification/rvgen/rvgen/utils.py
@@ -0,0 +1,36 @@
+#!/usr/bin/env python3
+# SPDX-License-Identifier: GPL-2.0-only
+
+
+def not_implemented(func):
+    """
+    Decorator to mark functions as not yet implemented.
+
+    This decorator wraps a function and raises a NotImplementedError when the
+    function is called, rather than executing the function body. This is useful
+    for defining interface methods or placeholder functions that need to be
+    implemented later.
+
+    Args:
+        func: The function to be wrapped.
+
+    Returns:
+        A wrapper function that raises NotImplementedError when called.
+
+    Raises:
+        NotImplementedError: Always raised when the decorated function is called.
+            The exception includes the function name and any arguments that were
+            passed to the function.
+
+    Example:
+        @not_implemented
+        def future_feature(arg1, arg2):
+            pass
+
+        # Calling future_feature will raise:
+        # NotImplementedError('future_feature', arg1_value, arg2_value)
+    """
+    def inner(*args, **kwargs):
+        raise NotImplementedError(func.__name__, *args, **kwargs)
+
+    return inner
-- 
2.52.0