Fix mypy.

mesonbuild/cargo/interpreter.py

@@ -27,11 +27,11 @@ from .. import coredata, options
 
 if T.TYPE_CHECKING:
     from types import ModuleType
+    from typing import Any
 
     from . import manifest
     from .. import mparser
     from ..environment import Environment
-    from ..coredata import KeyedOptionDictType
 
 # tomllib is present in python 3.11, before that it is a pypi module called tomli,
 # we try to import tomllib, then tomli,
@@ -700,7 +700,7 @@ def _create_lib(cargo: Manifest, build: builder.Builder, crate_type: manifest.CR
     ]
 
 
-def interpret(subp_name: str, subdir: str, env: Environment) -> T.Tuple[mparser.CodeBlockNode, KeyedOptionDictType]:
+def interpret(subp_name: str, subdir: str, env: Environment) -> T.Tuple[mparser.CodeBlockNode,  dict[OptionKey, options.UserOption[Any]]]:
     # subp_name should be in the form "foo-0.1-rs"
     package_name = subp_name.rsplit('-', 2)[0]
     manifests = _load_manifests(os.path.join(env.source_dir, subdir))

mesonbuild/compilers/c.py

@@ -541,6 +541,9 @@ class IntelClCCompiler(IntelVisualStudioLikeCompiler, VisualStudioLikeCCompilerM
     def get_options(self) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
         key = self.form_langopt_key('std')
+        # To shut up mypy.
+        if isinstance(opts, dict):
+            raise RuntimeError('This is a transitory issue that should not happen. Please report with full backtrace.')
         std_opt = opts.get_value_object(key)
         assert isinstance(std_opt, options.UserStdOption), 'for mypy'
         std_opt.set_versions(['c89', 'c99', 'c11'])

mesonbuild/compilers/compilers.py

@@ -25,6 +25,7 @@ from ..mesonlib import (
 from ..arglist import CompilerArgs
 
 if T.TYPE_CHECKING:
+    from typing import Any
     from ..build import BuildTarget, DFeatures
     from ..coredata import MutableKeyedOptionDictType, KeyedOptionDictType
     from ..envconfig import MachineInfo
@@ -247,7 +248,7 @@ BASE_OPTIONS: T.Mapping[OptionKey, BaseOption] = {
                                      choices=MSCRT_VALS + ['from_buildtype', 'static_from_buildtype']),
 }
 
-base_options: KeyedOptionDictType = {key: base_opt.init_option(key) for key, base_opt in BASE_OPTIONS.items()}
+base_options = {key: base_opt.init_option(key) for key, base_opt in BASE_OPTIONS.items()}
 
 def option_enabled(boptions: T.Set[OptionKey], options: 'KeyedOptionDictType',
                    option: OptionKey) -> bool:
@@ -1357,7 +1358,7 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta):
 def get_global_options(lang: str,
                        comp: T.Type[Compiler],
                        for_machine: MachineChoice,
-                       env: 'Environment') -> 'KeyedOptionDictType':
+                       env: 'Environment') -> 'dict[OptionKey, options.UserOption[Any]]':
     """Retrieve options that apply to all compilers for a given language."""
     description = f'Extra arguments passed to the {lang}'
     argkey = OptionKey('args', lang=lang, machine=for_machine)
@@ -1387,6 +1388,6 @@ def get_global_options(lang: str,
         # autotools compatibility.
         largs.extend_value(comp_options)
 
-    opts: 'KeyedOptionDictType' = {argkey: cargs, largkey: largs}
+    opts: 'dict[OptionKey, options.UserOption[Any]]' = {argkey: cargs, largkey: largs}
 
     return opts

mesonbuild/compilers/cpp.py

@@ -810,7 +810,7 @@ class CPP11AsCPP14Mixin(CompilerMixinBase):
             # copy the members because the option proxy doesn't support it.
             options = copy.deepcopy(options)
             if options.get_value(key) == 'vc++11':
-                options.set_value(key,'vc++14')
+                options.set_value(key, 'vc++14')
             else:
                 options.set_value(key,  'c++14')
         return super().get_option_compile_args(options)

mesonbuild/compilers/cuda.py

@@ -665,6 +665,7 @@ class CudaCompiler(Compiler):
         host_options = {key: master_options.get(key, opt) for key, opt in self.host_compiler.get_options().items()}
         std_key = OptionKey('std', machine=self.for_machine, lang=self.host_compiler.language)
         overrides = {std_key: 'none'}
+        # To shut up mypy.
         return coredata.OptionsView(host_options, overrides=overrides)
 
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:

mesonbuild/compilers/mixins/elbrus.py

@@ -84,9 +84,9 @@ class ElbrusCompiler(GnuLikeCompiler):
 
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
-        std = options[OptionKey('std', lang=self.language, machine=self.for_machine)]
-        if std.value != 'none':
-            args.append('-std=' + std.value)
+        std = options.get_value(OptionKey('std', lang=self.language, machine=self.for_machine))
+        if std != 'none':
+            args.append('-std=' + std)
         return args
 
     def openmp_flags(self) -> T.List[str]:

mesonbuild/coredata.py

@@ -32,6 +32,7 @@ import typing as T
 
 if T.TYPE_CHECKING:
     from typing_extensions import Protocol
+    from typing import Any
 
     from . import dependencies
     from .compilers.compilers import Compiler, CompileResult, RunResult, CompileCheckMode
@@ -40,6 +41,7 @@ if T.TYPE_CHECKING:
     from .mesonlib import FileOrString
     from .cmake.traceparser import CMakeCacheEntry
     from .interpreterbase import SubProject
+    from .options import UserOption
 
     class SharedCMDOptions(Protocol):
 
@@ -896,7 +898,7 @@ class OptionsView(abc.Mapping):
 
     # TODO: the typing here could be made more explicit using a TypeDict from
     # python 3.8 or typing_extensions
-    original_options: KeyedOptionDictType
+    original_options: T.Union[KeyedOptionDictType, 'dict[OptionKey, UserOption[Any]]']
     subproject: T.Optional[str] = None
     overrides: T.Optional[T.Mapping[OptionKey, T.Union[str, int, bool, T.List[str]]]] = None
 

mesonbuild/mconf.py

@@ -25,6 +25,8 @@ from .optinterpreter import OptionInterpreter
 
 if T.TYPE_CHECKING:
     from typing_extensions import Protocol
+    from typing import Any
+    from .options import UserOption
     import argparse
 
     class CMDOptions(coredata.SharedCMDOptions, Protocol):
@@ -186,7 +188,7 @@ class Conf:
                 items = [l[i] if l[i] else ' ' * four_column[i] for i in range(4)]
                 mlog.log(*items)
 
-    def split_options_per_subproject(self, options: 'coredata.KeyedOptionDictType') -> T.Dict[str, 'coredata.MutableKeyedOptionDictType']:
+    def split_options_per_subproject(self, options: 'T.Union[dict[OptionKey, UserOption[Any]], coredata.KeyedOptionDictType]') -> T.Dict[str, 'coredata.MutableKeyedOptionDictType']:
         result: T.Dict[str, 'coredata.MutableKeyedOptionDictType'] = {}
         for k, o in options.items():
             if k.subproject:
@@ -224,7 +226,7 @@ class Conf:
         self._add_line(mlog.normal_yellow(section + ':'), '', '', '')
         self.print_margin = 2
 
-    def print_options(self, title: str, opts: 'coredata.KeyedOptionDictType') -> None:
+    def print_options(self, title: str, opts: 'T.Union[dict[OptionKey, UserOption[Any]], coredata.KeyedOptionDictType]') -> None:
         if not opts:
             return
         if title:

mesonbuild/mintro.py

@@ -30,6 +30,8 @@ from .mparser import FunctionNode, ArrayNode, ArgumentNode, StringNode
 
 if T.TYPE_CHECKING:
     import argparse
+    from typing import Any
+    from .options import UserOption
 
     from .interpreter import Interpreter
     from .mparser import BaseNode
@@ -302,7 +304,7 @@ def list_buildoptions(coredata: cdata.CoreData, subprojects: T.Optional[T.List[s
                 for s in subprojects:
                     core_options[k.evolve(subproject=s)] = v
 
-    def add_keys(opts: 'cdata.KeyedOptionDictType', section: str) -> None:
+    def add_keys(opts: 'T.Union[dict[OptionKey, UserOption[Any]], cdata.KeyedOptionDictType]', section: str) -> None:
         for key, opt in sorted(opts.items()):
             optdict = {'name': str(key), 'value': opt.value, 'section': section,
                        'machine': key.machine.get_lower_case_name() if coredata.is_per_machine_option(key) else 'any'}

mesonbuild/options.py

@@ -481,7 +481,7 @@ class OptionStore:
     def __len__(self):
         return len(self.d)
 
-    def ensure_key(self,key: T.Union[OptionKey, str]) -> OptionKey:
+    def ensure_key(self, key: T.Union[OptionKey, str]) -> OptionKey:
         if isinstance(key, str):
             return OptionKey(key)
         return key
@@ -492,7 +492,7 @@ class OptionStore:
     def get_value(self, key: T.Union[OptionKey, str]) -> 'T.Any':
         return self.get_value_object(key).value
 
-    def add_system_option(self, key: T.Union[OptionKey, str], valobj: 'UserOption[T.Any'):
+    def add_system_option(self, key: T.Union[OptionKey, str], valobj: 'UserOption[T.Any]'):
         key = self.ensure_key(key)
         self.d[key] = valobj
 
@@ -501,15 +501,14 @@ class OptionStore:
         self.d[key] = valobj
 
     def set_value(self, key: T.Union[OptionKey, str], new_value: 'T.Any') -> bool:
-        key  = self.ensure_key(key)
+        key = self.ensure_key(key)
         return self.d[key].set_value(new_value)
 
     # FIXME, this should be removed.or renamed to "change_type_of_existing_object" or something like that
     def set_value_object(self, key: T.Union[OptionKey, str], new_object: 'UserOption[T.Any]') -> bool:
-        key  = self.ensure_key(key)
+        key = self.ensure_key(key)
         self.d[key] = new_object
 
-
     def remove(self, key):
         del self.d[key]
 
@@ -526,7 +525,7 @@ class OptionStore:
     def values(self):
         return self.d.values()
 
-    def items(self) -> ItemsView['OptionKey', 'USerOption[T.Any]']:
+    def items(self) -> ItemsView['OptionKey', 'UserOption[T.Any]']:
         return self.d.items()
 
     def update(self, *args, **kwargs):
@@ -535,5 +534,5 @@ class OptionStore:
     def setdefault(self, k, o):
         return self.d.setdefault(k, o)
 
-    def get(self, *args, **kwargs)-> UserOption:
+    def get(self, *args, **kwargs) -> UserOption:
         return self.d.get(*args, **kwargs)