interpreter: make trivial_operators per-class

Do not call update() and Enum.__hash__ a gazillion times; trivial
operators are the same for every instance of the class.

Introduce the infrastructure to build the MRO-resolved operators (so
the outcome same as if one called super().__init__) for each subclass
of InterpreterObject.

Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

5 files changed, 57 insertions, 54 deletions

diff --git a/mesonbuild/interpreter/primitives/array.py b/mesonbuild/interpreter/primitives/array.py
index 6582d4b60..088f1758b 100644
--- a/mesonbuild/interpreter/primitives/array.py
+++ b/mesonbuild/interpreter/primitives/array.py
@@ -27,6 +27,14 @@ if T.TYPE_CHECKING:
     from ...interpreterbase import TYPE_kwargs
 
 class ArrayHolder(ObjectHolder[T.List[TYPE_var]], IterableObject):
+    # Operators that only require type checks
+    TRIVIAL_OPERATORS = {
+        MesonOperator.EQUALS: (list, lambda obj, x: obj.held_object == x),
+        MesonOperator.NOT_EQUALS: (list, lambda obj, x: obj.held_object != x),
+        MesonOperator.IN: (object, lambda obj, x: x in obj.held_object),
+        MesonOperator.NOT_IN: (object, lambda obj, x: x not in obj.held_object),
+    }
+
     def __init__(self, obj: T.List[TYPE_var], interpreter: 'Interpreter') -> None:
         super().__init__(obj, interpreter)
         self.methods.update({
@@ -35,13 +43,6 @@ class ArrayHolder(ObjectHolder[T.List[TYPE_var]], IterableObject):
             'get': self.get_method,
         })
 
-        self.trivial_operators.update({
-            MesonOperator.EQUALS: (list, lambda obj, x: obj.held_object == x),
-            MesonOperator.NOT_EQUALS: (list, lambda obj, x: obj.held_object != x),
-            MesonOperator.IN: (object, lambda obj, x: x in obj.held_object),
-            MesonOperator.NOT_IN: (object, lambda obj, x: x not in obj.held_object),
-        })
-
         # Use actual methods for functions that require additional checks
         self.operators.update({
             MesonOperator.PLUS: ArrayHolder.op_plus,
diff --git a/mesonbuild/interpreter/primitives/boolean.py b/mesonbuild/interpreter/primitives/boolean.py
index 0695e2dd5..c5d6fe028 100644
--- a/mesonbuild/interpreter/primitives/boolean.py
+++ b/mesonbuild/interpreter/primitives/boolean.py
@@ -20,6 +20,13 @@ if T.TYPE_CHECKING:
     from ...interpreterbase import TYPE_var, TYPE_kwargs
 
 class BooleanHolder(ObjectHolder[bool]):
+    TRIVIAL_OPERATORS = {
+        MesonOperator.BOOL: (None, lambda obj, x: obj.held_object),
+        MesonOperator.NOT: (None, lambda obj, x: not obj.held_object),
+        MesonOperator.EQUALS: (bool, lambda obj, x: obj.held_object == x),
+        MesonOperator.NOT_EQUALS: (bool, lambda obj, x: obj.held_object != x),
+    }
+
     def __init__(self, obj: bool, interpreter: 'Interpreter') -> None:
         super().__init__(obj, interpreter)
         self.methods.update({
@@ -27,13 +34,6 @@ class BooleanHolder(ObjectHolder[bool]):
             'to_string': self.to_string_method,
         })
 
-        self.trivial_operators.update({
-            MesonOperator.BOOL: (None, lambda obj, x: obj.held_object),
-            MesonOperator.NOT: (None, lambda obj, x: not obj.held_object),
-            MesonOperator.EQUALS: (bool, lambda obj, x: obj.held_object == x),
-            MesonOperator.NOT_EQUALS: (bool, lambda obj, x: obj.held_object != x),
-        })
-
     def display_name(self) -> str:
         return 'bool'
 
diff --git a/mesonbuild/interpreter/primitives/dict.py b/mesonbuild/interpreter/primitives/dict.py
index ed2986da7..587a3015a 100644
--- a/mesonbuild/interpreter/primitives/dict.py
+++ b/mesonbuild/interpreter/primitives/dict.py
@@ -25,6 +25,18 @@ if T.TYPE_CHECKING:
     from ...interpreterbase import TYPE_kwargs
 
 class DictHolder(ObjectHolder[T.Dict[str, TYPE_var]], IterableObject):
+    # Operators that only require type checks
+    TRIVIAL_OPERATORS = {
+        # Arithmetic
+        MesonOperator.PLUS: (dict, lambda obj, x: {**obj.held_object, **x}),
+
+        # Comparison
+        MesonOperator.EQUALS: (dict, lambda obj, x: obj.held_object == x),
+        MesonOperator.NOT_EQUALS: (dict, lambda obj, x: obj.held_object != x),
+        MesonOperator.IN: (str, lambda obj, x: x in obj.held_object),
+        MesonOperator.NOT_IN: (str, lambda obj, x: x not in obj.held_object),
+    }
+
     def __init__(self, obj: T.Dict[str, TYPE_var], interpreter: 'Interpreter') -> None:
         super().__init__(obj, interpreter)
         self.methods.update({
@@ -33,17 +45,6 @@ class DictHolder(ObjectHolder[T.Dict[str, TYPE_var]], IterableObject):
             'get': self.get_method,
         })
 
-        self.trivial_operators.update({
-            # Arithmetic
-            MesonOperator.PLUS: (dict, lambda obj, x: {**obj.held_object, **x}),
-
-            # Comparison
-            MesonOperator.EQUALS: (dict, lambda obj, x: obj.held_object == x),
-            MesonOperator.NOT_EQUALS: (dict, lambda obj, x: obj.held_object != x),
-            MesonOperator.IN: (str, lambda obj, x: x in obj.held_object),
-            MesonOperator.NOT_IN: (str, lambda obj, x: x not in obj.held_object),
-        })
-
         # Use actual methods for functions that require additional checks
         self.operators.update({
             MesonOperator.INDEX: DictHolder.op_index,
diff --git a/mesonbuild/interpreter/primitives/integer.py b/mesonbuild/interpreter/primitives/integer.py
index 2d0915f7b..48ada78ad 100644
--- a/mesonbuild/interpreter/primitives/integer.py
+++ b/mesonbuild/interpreter/primitives/integer.py
@@ -15,6 +15,23 @@ if T.TYPE_CHECKING:
     from ...interpreterbase import TYPE_var, TYPE_kwargs
 
 class IntegerHolder(ObjectHolder[int]):
+    # Operators that only require type checks
+    TRIVIAL_OPERATORS = {
+        # Arithmetic
+        MesonOperator.UMINUS: (None, lambda obj, x: -obj.held_object),
+        MesonOperator.PLUS: (int, lambda obj, x: obj.held_object + x),
+        MesonOperator.MINUS: (int, lambda obj, x: obj.held_object - x),
+        MesonOperator.TIMES: (int, lambda obj, x: obj.held_object * x),
+
+        # Comparison
+        MesonOperator.EQUALS: (int, lambda obj, x: obj.held_object == x),
+        MesonOperator.NOT_EQUALS: (int, lambda obj, x: obj.held_object != x),
+        MesonOperator.GREATER: (int, lambda obj, x: obj.held_object > x),
+        MesonOperator.LESS: (int, lambda obj, x: obj.held_object < x),
+        MesonOperator.GREATER_EQUALS: (int, lambda obj, x: obj.held_object >= x),
+        MesonOperator.LESS_EQUALS: (int, lambda obj, x: obj.held_object <= x),
+    }
+
     def __init__(self, obj: int, interpreter: 'Interpreter') -> None:
         super().__init__(obj, interpreter)
         self.methods.update({
@@ -23,22 +40,6 @@ class IntegerHolder(ObjectHolder[int]):
             'to_string': self.to_string_method,
         })
 
-        self.trivial_operators.update({
-            # Arithmetic
-            MesonOperator.UMINUS: (None, lambda obj, x: -obj.held_object),
-            MesonOperator.PLUS: (int, lambda obj, x: obj.held_object + x),
-            MesonOperator.MINUS: (int, lambda obj, x: obj.held_object - x),
-            MesonOperator.TIMES: (int, lambda obj, x: obj.held_object * x),
-
-            # Comparison
-            MesonOperator.EQUALS: (int, lambda obj, x: obj.held_object == x),
-            MesonOperator.NOT_EQUALS: (int, lambda obj, x: obj.held_object != x),
-            MesonOperator.GREATER: (int, lambda obj, x: obj.held_object > x),
-            MesonOperator.LESS: (int, lambda obj, x: obj.held_object < x),
-            MesonOperator.GREATER_EQUALS: (int, lambda obj, x: obj.held_object >= x),
-            MesonOperator.LESS_EQUALS: (int, lambda obj, x: obj.held_object <= x),
-        })
-
         # Use actual methods for functions that require additional checks
         self.operators.update({
             MesonOperator.DIV: IntegerHolder.op_div,
diff --git a/mesonbuild/interpreter/primitives/string.py b/mesonbuild/interpreter/primitives/string.py
index 3cb78b310..673adcdc5 100644
--- a/mesonbuild/interpreter/primitives/string.py
+++ b/mesonbuild/interpreter/primitives/string.py
@@ -29,6 +29,19 @@ if T.TYPE_CHECKING:
     from ...interpreterbase import TYPE_var, TYPE_kwargs
 
 class StringHolder(ObjectHolder[str]):
+    TRIVIAL_OPERATORS = {
+        # Arithmetic
+        MesonOperator.PLUS: (str, lambda obj, x: obj.held_object + x),
+
+        # Comparison
+        MesonOperator.EQUALS: (str, lambda obj, x: obj.held_object == x),
+        MesonOperator.NOT_EQUALS: (str, lambda obj, x: obj.held_object != x),
+        MesonOperator.GREATER: (str, lambda obj, x: obj.held_object > x),
+        MesonOperator.LESS: (str, lambda obj, x: obj.held_object < x),
+        MesonOperator.GREATER_EQUALS: (str, lambda obj, x: obj.held_object >= x),
+        MesonOperator.LESS_EQUALS: (str, lambda obj, x: obj.held_object <= x),
+    }
+
     def __init__(self, obj: str, interpreter: 'Interpreter') -> None:
         super().__init__(obj, interpreter)
         self.methods.update({
@@ -49,19 +62,6 @@ class StringHolder(ObjectHolder[str]):
             'version_compare': self.version_compare_method,
         })
 
-        self.trivial_operators.update({
-            # Arithmetic
-            MesonOperator.PLUS: (str, lambda obj, x: obj.held_object + x),
-
-            # Comparison
-            MesonOperator.EQUALS: (str, lambda obj, x: obj.held_object == x),
-            MesonOperator.NOT_EQUALS: (str, lambda obj, x: obj.held_object != x),
-            MesonOperator.GREATER: (str, lambda obj, x: obj.held_object > x),
-            MesonOperator.LESS: (str, lambda obj, x: obj.held_object < x),
-            MesonOperator.GREATER_EQUALS: (str, lambda obj, x: obj.held_object >= x),
-            MesonOperator.LESS_EQUALS: (str, lambda obj, x: obj.held_object <= x),
-        })
-
         # Use actual methods for functions that require additional checks
         self.operators.update({
             MesonOperator.DIV: StringHolder.op_div,