mesonlib: make OptionOverrideProxy a true MutableMapping

So that we can actually use it anyplace that an OptionDictType could be
used. I've also done a bit optimizing/simplifying of the implementation.
This is needed for cuda, as it returns an OptionOverrideProxy where we
ask for an OptionDicType

mesonbuild/coredata.py

@@ -34,8 +34,9 @@ if T.TYPE_CHECKING:
     from . import dependencies
     from .compilers.compilers import Compiler, CompileResult  # noqa: F401
     from .environment import Environment
+    from .mesonlib import OptionOverrideProxy
 
-    OptionDictType = T.Dict[str, 'UserOption[T.Any]']
+    OptionDictType = T.Union[T.Dict[str, 'UserOption[T.Any]'], OptionOverrideProxy]
     CompilerCheckCacheKey = T.Tuple[T.Tuple[str, ...], str, str, T.Tuple[str, ...], str]
 
 version = '0.55.999'

mesonbuild/mesonlib.py

@@ -1696,7 +1696,7 @@ class OptionProxy(T.Generic[_T]):
         self.value = value
 
 
-class OptionOverrideProxy:
+class OptionOverrideProxy(collections.abc.MutableMapping):
 
     '''Mimic an option list but transparently override selected option
     values.
@@ -1706,23 +1706,30 @@ class OptionOverrideProxy:
     # python 3.8 or typing_extensions
 
     def __init__(self, overrides: T.Dict[str, T.Any], *options: 'OptionDictType'):
-        self.overrides = overrides
+        self.overrides = overrides.copy()
-        self.options = options
+        self.options = {}  # type: T.Dict[str, UserOption]
-
+        for o in options:
-    def __getitem__(self, option_name: str) -> T.Any:
+            self.options.update(o)
-        for opts in self.options:
+
-            if option_name in opts:
+    def __getitem__(self, key: str) -> T.Union['UserOption', OptionProxy]:
-                return self._get_override(option_name, opts[option_name])
+        if key in self.options:
-        raise KeyError('Option not found', option_name)
+            opt = self.options[key]
-
+            if key in self.overrides:
-    def _get_override(self, option_name: str, base_opt: 'UserOption[T.Any]') -> T.Union[OptionProxy[T.Any], 'UserOption[T.Any]']:
+                return OptionProxy(opt.validate_value(self.overrides[key]))
-        if option_name in self.overrides:
+            return opt
-            return OptionProxy(base_opt.validate_value(self.overrides[option_name]))
+        raise KeyError('Option not found', key)
-        return base_opt
+
-
+    def __setitem__(self, key: str, value: T.Union['UserOption', OptionProxy]) -> None:
-    def copy(self) -> T.Dict[str, T.Any]:
+        self.overrides[key] = value.value
-        result = {}  # type: T.Dict[str, T.Any]
+
-        for opts in self.options:
+    def __delitem__(self, key: str) -> None:
-            for option_name in opts:
+        del self.overrides[key]
-                result[option_name] = self._get_override(option_name, opts[option_name])
+
-        return result
+    def __iter__(self) -> T.Iterator[str]:
+        return iter(self.options)
+
+    def __len__(self) -> int:
+        return len(self.options)
+
+    def copy(self) -> 'OptionOverrideProxy':
+        return OptionOverrideProxy(self.overrides.copy(), self.options.copy())

mesonbuild/mintro.py

@@ -220,7 +220,7 @@ def list_buildoptions(coredata: cdata.CoreData, subprojects: T.Optional[T.List[s
                 sub_core_options[sub + ':' + k] = o
         core_options.update(sub_core_options)
 
-    def add_keys(options: T.Dict[str, cdata.UserOption], section: str, machine: str = 'any') -> None:
+    def add_keys(options: 'cdata.OptionDictType', section: str, machine: str = 'any') -> None:
         for key in sorted(options.keys()):
             opt = options[key]
             optdict = {'name': key, 'value': opt.value, 'section': section, 'machine': machine}