diff --git a/mesonbuild/backend/ninjabackend.py b/mesonbuild/backend/ninjabackend.py
index 4d9890ddfc7d..23fe2987d23f 100644
--- a/mesonbuild/backend/ninjabackend.py
+++ b/mesonbuild/backend/ninjabackend.py
@@ -638,7 +638,7 @@ def generate(self, capture: bool = False, vslite_ctx: T.Optional[T.Dict] = None)
             outfile.write('# Do not edit by hand.\n\n')
             outfile.write('ninja_required_version = 1.8.2\n\n')
 
-            num_pools = self.environment.coredata.optstore.get_value_safe('backend_max_links', int)
+            num_pools = self.environment.coredata.optstore.get_value('backend_max_links', int)
             if num_pools > 0:
                 outfile.write(f'''pool link_pool
   depth = {num_pools}
@@ -672,7 +672,7 @@ def generate(self, capture: bool = False, vslite_ctx: T.Optional[T.Dict] = None)
             mlog.log_timestamp("Dist generated")
             key = OptionKey('b_coverage')
             if (key in self.environment.coredata.optstore and
-                    self.environment.coredata.optstore.get_value_safe(key, bool)):
+                    self.environment.coredata.optstore.get_value(key, bool)):
                 gcovr_exe, gcovr_version, lcov_exe, lcov_version, genhtml_exe, llvm_cov_exe = environment.find_coverage_tools(self.environment.coredata)
                 mlog.debug(f'Using {gcovr_exe} ({gcovr_version}), {lcov_exe} and {llvm_cov_exe} for code coverage')
                 if gcovr_exe or (lcov_exe and genhtml_exe):
@@ -2325,7 +2325,7 @@ def _rsp_options(self, tool: T.Union['Compiler', 'StaticLinker', 'DynamicLinker'
         return options
 
     def generate_static_link_rules(self) -> None:
-        num_pools = self.environment.coredata.optstore.get_value_safe('backend_max_links', int)
+        num_pools = self.environment.coredata.optstore.get_value('backend_max_links', int)
         if 'java' in self.environment.coredata.compilers.host:
             self.generate_java_link()
         for for_machine in MachineChoice:
@@ -2373,7 +2373,7 @@ def generate_static_link_rules(self) -> None:
             self.add_rule(NinjaRule(rule, cmdlist, args, description, **options, extra=pool))
 
     def generate_dynamic_link_rules(self) -> None:
-        num_pools = self.environment.coredata.optstore.get_value_safe('backend_max_links', int)
+        num_pools = self.environment.coredata.optstore.get_value('backend_max_links', int)
         for for_machine in MachineChoice:
             complist = self.environment.coredata.compilers[for_machine]
             for langname, compiler in complist.items():
@@ -3746,7 +3746,7 @@ def generate_clangtool(self, name: str, extra_arg: T.Optional[str] = None) -> No
         if extra_arg:
             target_name += f'-{extra_arg}'
             extra_args.append(f'--{extra_arg}')
-        colorout = self.environment.coredata.optstore.get_value_safe('b_colorout', str, 'always')
+        colorout = self.environment.coredata.optstore.get_value('b_colorout', str, 'always')
         extra_args.extend(['--color', colorout])
         if not os.path.exists(os.path.join(self.environment.source_dir, '.clang-' + name)) and \
                 not os.path.exists(os.path.join(self.environment.source_dir, '_clang-' + name)):
@@ -3841,7 +3841,7 @@ def generate_ending(self) -> None:
         if ctlist:
             elem.add_dep(self.generate_custom_target_clean(ctlist))
 
-        if self.environment.coredata.optstore.get_value_safe('b_coverage', bool, False):
+        if self.environment.coredata.optstore.get_value('b_coverage', bool, False):
             self.generate_gcov_clean()
             elem.add_dep('clean-gcda')
             elem.add_dep('clean-gcno')
diff --git a/mesonbuild/backend/vs2010backend.py b/mesonbuild/backend/vs2010backend.py
index 0b29b6351aa5..2885182233f4 100644
--- a/mesonbuild/backend/vs2010backend.py
+++ b/mesonbuild/backend/vs2010backend.py
@@ -533,7 +533,7 @@ def generate_solution(self, sln_filename: str, projlist: T.List[Project]) -> Non
         replace_if_different(sln_filename, sln_filename_tmp)
 
     def generate_projects(self, vslite_ctx: dict = None) -> T.List[Project]:
-        startup_project = self.environment.coredata.optstore.get_value_safe('backend_startup_project', str)
+        startup_project = self.environment.coredata.optstore.get_value('backend_startup_project', str)
         projlist: T.List[Project] = []
         startup_idx = 0
         for (i, (name, target)) in enumerate(self.build.targets.items()):
diff --git a/mesonbuild/build.py b/mesonbuild/build.py
index b4bb258610d7..96af1e487134 100644
--- a/mesonbuild/build.py
+++ b/mesonbuild/build.py
@@ -682,7 +682,7 @@ def get_options(self) -> coredata.OptionsView:
     def get_option(self, key: 'OptionKey') -> T.Union[str, int, bool]:
         # TODO: if it's possible to annotate get_option or validate_option_value
         # in the future we might be able to remove the cast here
-        return T.cast('T.Union[str, int, bool]', self.options.get_value(key))
+        return T.cast('T.Union[str, int, bool]', self.options.get_value_unsafe(key))
 
     @staticmethod
     def parse_overrides(kwargs: T.Dict[str, T.Any]) -> T.Dict[OptionKey, str]:
@@ -1263,7 +1263,7 @@ def _extract_pic_pie(self, kwargs: T.Dict[str, T.Any], arg: str, option: str) ->
         if kwargs.get(arg) is not None:
             val = T.cast('bool', kwargs[arg])
         elif k in self.environment.coredata.optstore:
-            val = self.environment.coredata.optstore.get_value_safe(k, bool)
+            val = self.environment.coredata.optstore.get_value(k, bool)
         else:
             val = False
 
@@ -1974,7 +1974,7 @@ def __init__(
             kwargs):
         key = OptionKey('b_pie')
         if 'pie' not in kwargs and key in environment.coredata.optstore:
-            kwargs['pie'] = environment.coredata.optstore.get_value_safe(key, bool)
+            kwargs['pie'] = environment.coredata.optstore.get_value(key, bool)
         super().__init__(name, subdir, subproject, for_machine, sources, structured_sources, objects,
                          environment, compilers, kwargs)
         self.win_subsystem = kwargs.get('win_subsystem') or 'console'
@@ -2178,7 +2178,7 @@ def post_init(self) -> None:
                     self.suffix = 'a'
             else:
                 if 'c' in self.compilers and self.compilers['c'].get_id() == 'tasking':
-                    self.suffix = 'ma' if self.options.get_value_safe('b_lto', bool) and not self.prelink else 'a'
+                    self.suffix = 'ma' if self.options.get_value('b_lto', bool) and not self.prelink else 'a'
                 else:
                     self.suffix = 'a'
         self.filename = self.prefix + self.name + '.' + self.suffix
diff --git a/mesonbuild/cmake/common.py b/mesonbuild/cmake/common.py
index b20427dc4b17..135ef385b215 100644
--- a/mesonbuild/cmake/common.py
+++ b/mesonbuild/cmake/common.py
@@ -54,7 +54,7 @@
 def cmake_is_debug(env: 'Environment') -> bool:
     if OptionKey('b_vscrt') in env.coredata.optstore:
         is_debug = env.coredata.get_option(OptionKey('buildtype')) == 'debug'
-        if env.coredata.optstore.get_value_safe('b_vscrt', str) in {'mdd', 'mtd'}:
+        if env.coredata.optstore.get_value('b_vscrt', str) in {'mdd', 'mtd'}:
             is_debug = True
         return is_debug
     else:
diff --git a/mesonbuild/cmake/executor.py b/mesonbuild/cmake/executor.py
index 5aa2e6486268..c96135532538 100644
--- a/mesonbuild/cmake/executor.py
+++ b/mesonbuild/cmake/executor.py
@@ -52,7 +52,7 @@ def __init__(self, environment: 'Environment', version: str, for_machine: Machin
             self.cmakebin = None
             return
 
-        self.prefix_paths = self.environment.coredata.optstore.get_value_safe(OptionKey('cmake_prefix_path', machine=self.for_machine), list)
+        self.prefix_paths = self.environment.coredata.optstore.get_value(OptionKey('cmake_prefix_path', machine=self.for_machine), list)
         if self.prefix_paths:
             self.extra_cmake_args += ['-DCMAKE_PREFIX_PATH={}'.format(';'.join(self.prefix_paths))]
 
diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py
index 64fc46889be1..a691e08b421b 100644
--- a/mesonbuild/compilers/c.py
+++ b/mesonbuild/compilers/c.py
@@ -133,7 +133,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -142,7 +142,7 @@ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         if self.info.is_windows() or self.info.is_cygwin():
             # without a typedict mypy can't understand this.
             key = self.form_compileropt_key('winlibs')
-            return options.get_value_safe(key, list).copy()
+            return options.get_value(key, list).copy()
         return []
 
 
@@ -218,7 +218,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -262,7 +262,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -270,7 +270,7 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
     def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         if self.info.is_windows() or self.info.is_cygwin():
             key = self.form_compileropt_key('winlibs')
-            libs: T.List[str] = options.get_value_safe(key, list).copy()
+            libs: T.List[str] = options.get_value(key, list).copy()
             return libs
         return []
 
@@ -380,7 +380,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -407,7 +407,7 @@ def get_options(self) -> MutableKeyedOptionDictType:
     def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         # need a TypeDict to make this work
         key = self.form_compileropt_key('winlibs')
-        return options.get_value_safe(key, list).copy()
+        return options.get_value(key, list).copy()
 
 
 class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompiler):
@@ -440,7 +440,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         # As of MVSC 16.8, /std:c11 and /std:c17 are the only valid C standard options.
         if std == 'c11':
             args.append('/std:c11')
@@ -461,7 +461,7 @@ def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoic
 
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != "none":
             return [f'/clang:-std={std}']
         return []
@@ -494,7 +494,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std == 'c89':
             mlog.log("ICL doesn't explicitly implement c89, setting the standard to 'none', which is close.", once=True)
         elif std != 'none':
@@ -528,7 +528,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('--' + std)
         return args
@@ -561,7 +561,7 @@ def get_no_stdinc_args(self) -> T.List[str]:
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std == 'c89':
             args.append('-lang=c')
         elif std == 'c99':
@@ -609,7 +609,7 @@ def get_no_stdinc_args(self) -> T.List[str]:
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-ansi')
             args.append('-std=' + std)
@@ -693,7 +693,7 @@ def get_no_stdinc_args(self) -> T.List[str]:
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('--' + std)
         return args
@@ -727,7 +727,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-lang')
             args.append(std)
@@ -755,7 +755,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-lang ' + std)
         return args
diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py
index fcde6995a790..8c9585e33a12 100644
--- a/mesonbuild/compilers/compilers.py
+++ b/mesonbuild/compilers/compilers.py
@@ -261,7 +261,7 @@ def option_enabled(boptions: T.Set[OptionKey], options: 'KeyedOptionDictType',
     try:
         if option not in boptions:
             return False
-        return options.get_value_safe(option, bool)  # could also be str?
+        return options.get_value(option, bool)  # could also be str?
     except KeyError:
         return False
 
@@ -272,30 +272,30 @@ def are_asserts_disabled(options: KeyedOptionDictType) -> bool:
     :param options: OptionDictionary
     :return: whether to disable assertions or not
     """
-    return (options.get_value_safe('b_ndebug', str) == 'true' or
-            (options.get_value_safe('b_ndebug', str) == 'if-release' and
-             options.get_value_safe('buildtype', str) in {'release', 'plain'}))
+    return (options.get_value('b_ndebug', str) == 'true' or
+            (options.get_value('b_ndebug', str) == 'if-release' and
+             options.get_value('buildtype', str) in {'release', 'plain'}))
 
 
 def get_base_compile_args(options: 'KeyedOptionDictType', compiler: 'Compiler', env: 'Environment') -> T.List[str]:
     args: T.List[str] = []
     try:
-        if options.get_value_safe(OptionKey('b_lto'), bool):
+        if options.get_value(OptionKey('b_lto'), bool):
             args.extend(compiler.get_lto_compile_args(
-                threads=options.get_value_safe(OptionKey('b_lto_threads'), int, 0),
-                mode=options.get_value_safe(OptionKey('b_lto_mode'), str, 'default')))
+                threads=options.get_value(OptionKey('b_lto_threads'), int, 0),
+                mode=options.get_value(OptionKey('b_lto_mode'), str, 'default')))
     except (KeyError, AttributeError):
         pass
     try:
-        args += compiler.get_colorout_args(options.get_value_safe(OptionKey('b_colorout'), str))
+        args += compiler.get_colorout_args(options.get_value(OptionKey('b_colorout'), str))
     except (KeyError, AttributeError):
         pass
     try:
-        args += compiler.sanitizer_compile_args(options.get_value_safe(OptionKey('b_sanitize'), str))
+        args += compiler.sanitizer_compile_args(options.get_value(OptionKey('b_sanitize'), str))
     except (KeyError, AttributeError):
         pass
     try:
-        pgo_val = options.get_value_safe(OptionKey('b_pgo'), str)
+        pgo_val = options.get_value(OptionKey('b_pgo'), str)
         if pgo_val == 'generate':
             args.extend(compiler.get_profile_generate_args())
         elif pgo_val == 'use':
@@ -303,7 +303,7 @@ def get_base_compile_args(options: 'KeyedOptionDictType', compiler: 'Compiler',
     except (KeyError, AttributeError):
         pass
     try:
-        if options.get_value_safe(OptionKey('b_coverage'), bool):
+        if options.get_value(OptionKey('b_coverage'), bool):
             args += compiler.get_coverage_args()
     except (KeyError, AttributeError):
         pass
@@ -316,8 +316,8 @@ def get_base_compile_args(options: 'KeyedOptionDictType', compiler: 'Compiler',
         args.append('-fembed-bitcode')
     try:
         try:
-            crt_val = options.get_value_safe(OptionKey('b_vscrt'), str)
-            buildtype = options.get_value_safe(OptionKey('buildtype'), str)
+            crt_val = options.get_value(OptionKey('b_vscrt'), str)
+            buildtype = options.get_value(OptionKey('buildtype'), str)
             args += compiler.get_crt_compile_args(crt_val, buildtype)
         except AttributeError:
             pass
@@ -329,27 +329,27 @@ def get_base_link_args(options: 'KeyedOptionDictType', linker: 'Compiler',
                        is_shared_module: bool, build_dir: str) -> T.List[str]:
     args: T.List[str] = []
     try:
-        if options.get_value_safe('b_lto', bool):
-            if options.get_value_safe('werror', bool):
+        if options.get_value('b_lto', bool):
+            if options.get_value('werror', bool):
                 args.extend(linker.get_werror_args())
 
             thinlto_cache_dir = None
-            if options.get_value_safe(OptionKey('b_thinlto_cache'), bool, False):
-                thinlto_cache_dir = options.get_value_safe(OptionKey('b_thinlto_cache_dir'), str, '')
+            if options.get_value(OptionKey('b_thinlto_cache'), bool, False):
+                thinlto_cache_dir = options.get_value(OptionKey('b_thinlto_cache_dir'), str, '')
                 if thinlto_cache_dir == '':
                     thinlto_cache_dir = os.path.join(build_dir, 'meson-private', 'thinlto-cache')
             args.extend(linker.get_lto_link_args(
-                threads=options.get_value_safe(OptionKey('b_lto_threads'), int, 0),
-                mode=options.get_value_safe(OptionKey('b_lto_mode'), str, 'default'),
+                threads=options.get_value(OptionKey('b_lto_threads'), int, 0),
+                mode=options.get_value(OptionKey('b_lto_mode'), str, 'default'),
                 thinlto_cache_dir=thinlto_cache_dir))
     except (KeyError, AttributeError):
         pass
     try:
-        args += linker.sanitizer_link_args(options.get_value_safe('b_sanitize', str))
+        args += linker.sanitizer_link_args(options.get_value('b_sanitize', str))
     except (KeyError, AttributeError):
         pass
     try:
-        pgo_val = options.get_value_safe('b_pgo', str)
+        pgo_val = options.get_value('b_pgo', str)
         if pgo_val == 'generate':
             args.extend(linker.get_profile_generate_args())
         elif pgo_val == 'use':
@@ -357,7 +357,7 @@ def get_base_link_args(options: 'KeyedOptionDictType', linker: 'Compiler',
     except (KeyError, AttributeError):
         pass
     try:
-        if options.get_value_safe('b_coverage', bool):
+        if options.get_value('b_coverage', bool):
             args += linker.get_coverage_link_args()
     except (KeyError, AttributeError):
         pass
@@ -384,8 +384,8 @@ def get_base_link_args(options: 'KeyedOptionDictType', linker: 'Compiler',
 
     try:
         try:
-            crt_val = options.get_value_safe(OptionKey('b_vscrt'), str)
-            buildtype = options.get_value_safe(OptionKey('buildtype'), str)
+            crt_val = options.get_value(OptionKey('b_vscrt'), str)
+            buildtype = options.get_value(OptionKey('buildtype'), str)
             args += linker.get_crt_link_args(crt_val, buildtype)
         except AttributeError:
             pass
diff --git a/mesonbuild/compilers/cpp.py b/mesonbuild/compilers/cpp.py
index 32a377137747..110f9b9ad19a 100644
--- a/mesonbuild/compilers/cpp.py
+++ b/mesonbuild/compilers/cpp.py
@@ -268,15 +268,15 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append(self._find_best_cpp_std(std))
 
         key = self.form_compileropt_key('eh')
-        non_msvc_eh_options(options.get_value_safe(key, str), args)
+        non_msvc_eh_options(options.get_value(key, str), args)
 
         key = self.form_compileropt_key('debugstl')
-        if options.get_value_safe(key, bool):
+        if options.get_value(key, bool):
             args.append('-D_GLIBCXX_DEBUG=1')
 
             # We can't do _LIBCPP_DEBUG because it's unreliable unless libc++ was built with it too:
@@ -286,7 +286,7 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
                 args.append('-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG')
 
         key = self.form_compileropt_key('rtti')
-        if not options.get_value_safe(key, bool):
+        if not options.get_value(key, bool):
             args.append('-fno-rtti')
 
         return args
@@ -295,7 +295,7 @@ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         if self.info.is_windows() or self.info.is_cygwin():
             # without a typedict mypy can't understand this.
             key = self.form_compileropt_key('winlibs')
-            return options.get_value_safe(key, list).copy()
+            return options.get_value(key, list).copy()
         return []
 
     def get_assert_args(self, disable: bool, env: 'Environment') -> T.List[str]:
@@ -362,7 +362,7 @@ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append(self._find_best_cpp_std(std))
         return args
@@ -406,12 +406,12 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-std=' + std)
 
         key = self.form_compileropt_key('eh')
-        non_msvc_eh_options(options.get_value_safe(key, str), args)
+        non_msvc_eh_options(options.get_value(key, str), args)
 
         return args
 
@@ -475,16 +475,16 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
         rttikey = self.form_compileropt_key('rtti')
         debugstlkey = self.form_compileropt_key('debugstl')
 
-        std = options.get_value_safe(stdkey, str)
+        std = options.get_value(stdkey, str)
         if std != 'none':
             args.append(self._find_best_cpp_std(std))
 
-        non_msvc_eh_options(options.get_value_safe(ehkey, str), args)
+        non_msvc_eh_options(options.get_value(ehkey, str), args)
 
-        if not options.get_value_safe(rttikey, bool):
+        if not options.get_value(rttikey, bool):
             args.append('-fno-rtti')
 
-        if options.get_value_safe(debugstlkey, bool):
+        if options.get_value(debugstlkey, bool):
             args.append('-D_GLIBCXX_DEBUG=1')
         return args
 
@@ -492,7 +492,7 @@ def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         if self.info.is_windows() or self.info.is_cygwin():
             # without a typedict mypy can't understand this.
             key = self.form_compileropt_key('winlibs')
-            return options.get_value_safe(key, list).copy()
+            return options.get_value(key, list).copy()
         return []
 
     def get_assert_args(self, disable: bool, env: 'Environment') -> T.List[str]:
@@ -616,15 +616,15 @@ def has_function(self, funcname: str, prefix: str, env: 'Environment', *,
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append(self._find_best_cpp_std(std))
 
         key = self.form_compileropt_key('eh')
-        non_msvc_eh_options(options.get_value_safe(key, str), args)
+        non_msvc_eh_options(options.get_value(key, str), args)
 
         key = self.form_compileropt_key('debugstl')
-        if options.get_value_safe(key, bool):
+        if options.get_value(key, bool):
             args.append('-D_GLIBCXX_DEBUG=1')
         return args
 
@@ -689,18 +689,18 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             remap_cpp03 = {
                 'c++03': 'c++98',
                 'gnu++03': 'gnu++98'
             }
             args.append('-std=' + remap_cpp03.get(std, std))
-        if options.get_value_safe(key.evolve('eh'), str) == 'none':
+        if options.get_value(key.evolve('eh'), str) == 'none':
             args.append('-fno-exceptions')
-        if not options.get_value_safe(key.evolve('rtti'), bool):
+        if not options.get_value(key.evolve('rtti'), bool):
             args.append('-fno-rtti')
-        if options.get_value_safe(key.evolve('debugstl'), bool):
+        if options.get_value(key.evolve('debugstl'), bool):
             args.append('-D_GLIBCXX_DEBUG=1')
         return args
 
@@ -734,7 +734,7 @@ class VisualStudioLikeCPPCompilerMixin(CompilerMixinBase):
     def get_option_link_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         # need a typeddict for this
         key = self.form_compileropt_key('winlibs')
-        return options.get_value_safe(key, list).copy()
+        return options.get_value(key, list).copy()
 
     def _get_options_impl(self, opts: 'MutableKeyedOptionDictType', cpp_stds: T.List[str]) -> 'MutableKeyedOptionDictType':
         opts = super().get_options()
@@ -767,7 +767,7 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
 
-        eh = options.get_value_safe(self.form_compileropt_key('eh'), str)
+        eh = options.get_value(self.form_compileropt_key('eh'), str)
         if eh == 'default':
             args.append('/EHsc')
         elif eh == 'none':
@@ -775,10 +775,10 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
         else:
             args.append('/EH' + eh)
 
-        if not options.get_value_safe(self.form_compileropt_key('rtti'), bool):
+        if not options.get_value(self.form_compileropt_key('rtti'), bool):
             args.append('/GR-')
 
-        permissive, ver = self.VC_VERSION_MAP[options.get_value_safe(key, str)]
+        permissive, ver = self.VC_VERSION_MAP[options.get_value(key, str)]
 
         if ver is not None:
             args.append(f'/std:c++{ver}')
@@ -806,7 +806,7 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
         # (i.e., after VS2015U3)
         # if one is using anything before that point, one cannot set the standard.
         key = self.form_compileropt_key('std')
-        if options.get_value_safe(key, str) in {'vc++11', 'c++11'}:
+        if options.get_value(key, str) in {'vc++11', 'c++11'}:
             mlog.warning(self.id, 'does not support C++11;',
                          'attempting best effort; setting the standard to C++14',
                          once=True, fatal=False)
@@ -814,7 +814,7 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
             # deepcopy since we're messing with members, and we can't simply
             # copy the members because the option proxy doesn't support it.
             options = copy.deepcopy(options)
-            if options.get_value_safe(key, str) == 'vc++11':
+            if options.get_value(key, str) == 'vc++11':
                 options.set_value(key, 'vc++14')
             else:
                 options.set_value(key,  'c++14')
@@ -853,7 +853,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
 
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         key = self.form_compileropt_key('std')
-        if options.get_value_safe(key, str) != 'none' and version_compare(self.version, '<19.00.24210'):
+        if options.get_value(key, str) != 'none' and version_compare(self.version, '<19.00.24210'):
             mlog.warning('This version of MSVC does not support cpp_std arguments', fatal=False)
             options = copy.copy(options)
             options.set_value(key, 'none')
@@ -934,7 +934,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std == 'c++11':
             args.append('--cpp11')
         elif std == 'c++03':
@@ -996,7 +996,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('--' + std)
         return args
@@ -1036,7 +1036,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-lang')
             args.append(std)
@@ -1064,7 +1064,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-lang ' + std)
         return args
diff --git a/mesonbuild/compilers/cuda.py b/mesonbuild/compilers/cuda.py
index 56aea9f7d982..d0ea719a94d1 100644
--- a/mesonbuild/compilers/cuda.py
+++ b/mesonbuild/compilers/cuda.py
@@ -684,7 +684,7 @@ def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]
         # and attempting to use it will result in a warning: https://stackoverflow.com/a/51272091/741027
         if not is_windows():
             key = self.form_compileropt_key('std')
-            std = options.get_value_safe(key, str)
+            std = options.get_value(key, str)
             if std != 'none':
                 args.append('--std=' + std)
 
@@ -804,7 +804,7 @@ def get_dependency_link_args(self, dep: 'Dependency') -> T.List[str]:
 
     def get_ccbin_args(self, ccoptions: 'KeyedOptionDictType') -> T.List[str]:
         key = self.form_compileropt_key('ccbindir')
-        ccbindir = ccoptions.get_value_safe(key, str)
+        ccbindir = ccoptions.get_value(key, str)
         if ccbindir:
             return [self._shield_nvcc_list_arg('-ccbin='+ccbindir, False)]
         else:
diff --git a/mesonbuild/compilers/cython.py b/mesonbuild/compilers/cython.py
index 4337c0707443..95ab0ffb1a5f 100644
--- a/mesonbuild/compilers/cython.py
+++ b/mesonbuild/compilers/cython.py
@@ -88,10 +88,10 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('version')
-        version = options.get_value_safe(key, str)
+        version = options.get_value(key, str)
         args.append(f'-{version}')
         key = self.form_compileropt_key('language')
-        lang = options.get_value_safe(key, str)
+        lang = options.get_value(key, str)
         if lang == 'cpp':
             args.append('--cplus')
         return args
diff --git a/mesonbuild/compilers/fortran.py b/mesonbuild/compilers/fortran.py
index 72fc6c8ff2d8..90275e22dcb7 100644
--- a/mesonbuild/compilers/fortran.py
+++ b/mesonbuild/compilers/fortran.py
@@ -287,7 +287,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -421,7 +421,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         stds = {'legacy': 'none', 'f95': 'f95', 'f2003': 'f03', 'f2008': 'f08', 'f2018': 'f18'}
         if std != 'none':
             args.append('-stand=' + stds[std])
@@ -475,7 +475,7 @@ def get_options(self) -> 'MutableKeyedOptionDictType':
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         stds = {'legacy': 'none', 'f95': 'f95', 'f2003': 'f03', 'f2008': 'f08', 'f2018': 'f18'}
         if std != 'none':
             args.append('/stand:' + stds[std])
diff --git a/mesonbuild/compilers/mixins/clike.py b/mesonbuild/compilers/mixins/clike.py
index 4365028b54b5..e6e30f9f39f7 100644
--- a/mesonbuild/compilers/mixins/clike.py
+++ b/mesonbuild/compilers/mixins/clike.py
@@ -376,8 +376,8 @@ def _get_basic_compiler_args(self, env: 'Environment', mode: CompileCheckMode) -
             # linking with static libraries since MSVC won't select a CRT for
             # us in that case and will error out asking us to pick one.
             try:
-                crt_val = env.coredata.optstore.get_value_safe('b_vscrt', str)
-                buildtype = env.coredata.optstore.get_value_safe('buildtype', str)
+                crt_val = env.coredata.optstore.get_value('b_vscrt', str)
+                buildtype = env.coredata.optstore.get_value('buildtype', str)
                 cargs += self.get_crt_compile_args(crt_val, buildtype)
             except (KeyError, AttributeError):
                 pass
diff --git a/mesonbuild/compilers/mixins/elbrus.py b/mesonbuild/compilers/mixins/elbrus.py
index fa2c91724b01..c0f0378b5126 100644
--- a/mesonbuild/compilers/mixins/elbrus.py
+++ b/mesonbuild/compilers/mixins/elbrus.py
@@ -85,7 +85,7 @@ def get_pch_suffix(self) -> str:
 
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args: T.List[str] = []
-        std = options.get_value_safe(OptionKey(f'{self.language}_std', machine=self.for_machine), str)
+        std = options.get_value(OptionKey(f'{self.language}_std', machine=self.for_machine), str)
         if std != 'none':
             args.append('-std=' + std)
         return args
diff --git a/mesonbuild/compilers/mixins/emscripten.py b/mesonbuild/compilers/mixins/emscripten.py
index 12edadf2f26f..a35de2c68f48 100644
--- a/mesonbuild/compilers/mixins/emscripten.py
+++ b/mesonbuild/compilers/mixins/emscripten.py
@@ -51,7 +51,7 @@ def _get_compile_output(self, dirname: str, mode: CompileCheckMode) -> str:
 
     def thread_link_flags(self, env: 'Environment') -> T.List[str]:
         args = ['-pthread']
-        count = env.coredata.optstore.get_value_safe(OptionKey(f'{self.language}_thread_count', machine=self.for_machine), int)
+        count = env.coredata.optstore.get_value(OptionKey(f'{self.language}_thread_count', machine=self.for_machine), int)
         if count:
             args.append(f'-sPTHREAD_POOL_SIZE={count}')
         return args
diff --git a/mesonbuild/compilers/objc.py b/mesonbuild/compilers/objc.py
index 9959fab17876..ffeb6f7c7ee4 100644
--- a/mesonbuild/compilers/objc.py
+++ b/mesonbuild/compilers/objc.py
@@ -77,7 +77,7 @@ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_
 
     def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
         args = []
-        std = options.get_value_safe(self.form_compileropt_key('std'), str)
+        std = options.get_value(self.form_compileropt_key('std'), str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -111,7 +111,7 @@ def make_option_name(self, key: OptionKey) -> str:
 
     def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
         args = []
-        std = options.get_value_safe(self.form_compileropt_key('std'), str)
+        std = options.get_value(self.form_compileropt_key('std'), str)
         if std != 'none':
             args.append('-std=' + std)
         return args
diff --git a/mesonbuild/compilers/objcpp.py b/mesonbuild/compilers/objcpp.py
index 5cecd6ccaf8a..db13a6678828 100644
--- a/mesonbuild/compilers/objcpp.py
+++ b/mesonbuild/compilers/objcpp.py
@@ -82,7 +82,7 @@ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_
 
     def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
         args = []
-        std = options.get_value_safe(self.form_compileropt_key('std'), str)
+        std = options.get_value(self.form_compileropt_key('std'), str)
         if std != 'none':
             args.append('-std=' + std)
         return args
@@ -107,7 +107,7 @@ def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_
 
     def get_option_compile_args(self, options: 'coredata.KeyedOptionDictType') -> T.List[str]:
         args = []
-        std = options.get_value_safe(self.form_compileropt_key('std'), str)
+        std = options.get_value(self.form_compileropt_key('std'), str)
         if std != 'none':
             args.append('-std=' + std)
         return args
diff --git a/mesonbuild/compilers/rust.py b/mesonbuild/compilers/rust.py
index ad48c417f629..7d8ba07071d7 100644
--- a/mesonbuild/compilers/rust.py
+++ b/mesonbuild/compilers/rust.py
@@ -240,7 +240,7 @@ def get_dependency_compile_args(self, dep: 'Dependency') -> T.List[str]:
     def get_option_compile_args(self, options: 'KeyedOptionDictType') -> T.List[str]:
         args = []
         key = self.form_compileropt_key('std')
-        std = options.get_value_safe(key, str)
+        std = options.get_value(key, str)
         if std != 'none':
             args.append('--edition=' + std)
         return args
diff --git a/mesonbuild/coredata.py b/mesonbuild/coredata.py
index 99fd91f578a5..71d59952fc1e 100644
--- a/mesonbuild/coredata.py
+++ b/mesonbuild/coredata.py
@@ -153,8 +153,8 @@ def __init__(self, builtins: 'KeyedOptionDictType', for_machine: MachineChoice):
 
     def __calculate_subkey(self, type_: DependencyCacheType) -> T.Tuple[str, ...]:
         data: T.Dict[DependencyCacheType, T.List[str]] = {
-            DependencyCacheType.PKG_CONFIG: self.__builtins.get_value_safe(self.__pkg_conf_key, list),
-            DependencyCacheType.CMAKE: self.__builtins.get_value_safe(self.__cmake_key, list),
+            DependencyCacheType.PKG_CONFIG: self.__builtins.get_value(self.__pkg_conf_key, list),
+            DependencyCacheType.CMAKE: self.__builtins.get_value(self.__cmake_key, list),
             DependencyCacheType.OTHER: [],
         }
         assert type_ in data, 'Someone forgot to update subkey calculations for a new type'
@@ -418,7 +418,7 @@ def add_builtin_option(opts_map: options.OptionStore, key: OptionKey,
             if opt.yielding:
                 # This option is global and not per-subproject
                 return
-            value = opts_map.get_value(key.as_root())
+            value = opts_map.get_value_unsafe(key.as_root())
         else:
             value = None
 
@@ -466,7 +466,7 @@ def set_option(self, key: OptionKey, value: ElementaryOptionValues, first_invoca
                 assert isinstance(value, str), 'for mypy'
                 value = self.sanitize_prefix(value)
             else:
-                prefix = self.optstore.get_value_safe('prefix', str)
+                prefix = self.optstore.get_value('prefix', str)
                 value = self.sanitize_dir_option_value(prefix, key, value)
 
         try:
@@ -523,7 +523,7 @@ def clear_cache(self) -> None:
 
     def get_nondefault_buildtype_args(self) -> T.List[T.Union[T.Tuple[str, str, str], T.Tuple[str, bool, bool]]]:
         result: T.List[T.Union[T.Tuple[str, str, str], T.Tuple[str, bool, bool]]] = []
-        value = self.optstore.get_value_safe('buildtype', str)
+        value = self.optstore.get_value('buildtype', str)
         if value == 'plain':
             opt = 'plain'
             debug = False
@@ -542,8 +542,8 @@ def get_nondefault_buildtype_args(self) -> T.List[T.Union[T.Tuple[str, str, str]
         else:
             assert value == 'custom'
             return []
-        actual_opt = self.optstore.get_value_safe('optimization', str)
-        actual_debug = self.optstore.get_value_safe('debug', bool)
+        actual_opt = self.optstore.get_value('optimization', str)
+        actual_debug = self.optstore.get_value('debug', bool)
         if actual_opt != opt:
             result.append(('optimization', actual_opt, opt))
         if actual_debug != debug:
@@ -585,12 +585,12 @@ def is_per_machine_option(self, optname: OptionKey) -> bool:
     def get_external_args(self, for_machine: MachineChoice, lang: str) -> T.List[str]:
         # mypy cannot analyze type of OptionKey
         key = OptionKey(f'{lang}_args', machine=for_machine)
-        return self.optstore.get_value_safe(key, list)
+        return self.optstore.get_value(key, list)
 
     def get_external_link_args(self, for_machine: MachineChoice, lang: str) -> T.List[str]:
         # mypy cannot analyze type of OptionKey
         key = OptionKey(f'{lang}_link_args', machine=for_machine)
-        return self.optstore.get_value_safe(key, list)
+        return self.optstore.get_value(key, list)
 
     def update_project_options(self, project_options: 'MutableKeyedOptionDictType', subproject: SubProject) -> None:
         for key, value in project_options.items():
@@ -959,17 +959,17 @@ def __getitem__(self, key: OptionKey) -> options.AnyOptionType:
                 opt.set_value(override_value)
         return opt
 
-    def get_value(self, key: T.Union[str, OptionKey]) -> ElementaryOptionValues:
+    def get_value_unsafe(self, key: T.Union[str, OptionKey]) -> ElementaryOptionValues:
         if isinstance(key, str):
             key = OptionKey(key)
         return self[key].value
 
-    def get_value_safe(self, key: T.Union[OptionKey, str],
-                       type_: T.Type[ElementaryOptionTypes],
-                       fallback: T.Optional[ElementaryOptionTypes] = None,
-                       ) -> ElementaryOptionTypes:
+    def get_value(self, key: T.Union[OptionKey, str],
+                  type_: T.Type[ElementaryOptionTypes],
+                  fallback: T.Optional[ElementaryOptionTypes] = None,
+                  ) -> ElementaryOptionTypes:
         try:
-            v = self.get_value(key)
+            v = self.get_value_unsafe(key)
             assert isinstance(v, type_), 'for mypy'
             return v
         except KeyError:
diff --git a/mesonbuild/dependencies/boost.py b/mesonbuild/dependencies/boost.py
index cc9a50149fd0..cdaa476f3014 100644
--- a/mesonbuild/dependencies/boost.py
+++ b/mesonbuild/dependencies/boost.py
@@ -581,8 +581,8 @@ def filter_libraries(self, libs: T.List[BoostLibraryFile], lib_vers: str) -> T.L
         # MSVC is very picky with the library tags
         vscrt = ''
         try:
-            crt_val = self.env.coredata.optstore.get_value_safe('b_vscrt', str)
-            buildtype = self.env.coredata.optstore.get_value_safe('buildtype', str)
+            crt_val = self.env.coredata.optstore.get_value('b_vscrt', str)
+            buildtype = self.env.coredata.optstore.get_value('buildtype', str)
             vscrt = self.clib_compiler.get_crt_compile_args(crt_val, buildtype)[0]
         except (KeyError, IndexError, AttributeError):
             pass
diff --git a/mesonbuild/dependencies/pkgconfig.py b/mesonbuild/dependencies/pkgconfig.py
index eb3a0cf99760..d127df56e02c 100644
--- a/mesonbuild/dependencies/pkgconfig.py
+++ b/mesonbuild/dependencies/pkgconfig.py
@@ -256,7 +256,7 @@ def _check_pkgconfig(self, pkgbin: ExternalProgram) -> T.Optional[str]:
     def _get_env(self, uninstalled: bool = False) -> EnvironmentVariables:
         env = EnvironmentVariables()
         key = OptionKey('pkg_config_path', machine=self.for_machine)
-        extra_paths = self.env.coredata.optstore.get_value_safe(key, list).copy()
+        extra_paths = self.env.coredata.optstore.get_value(key, list).copy()
         if uninstalled:
             bpath = self.env.get_build_dir()
             if bpath is not None:
@@ -419,7 +419,7 @@ def _search_libs(self, libs_in: ImmutableListProtocol[str], raw_libs_in: Immutab
         #
         # Only prefix_libpaths are reordered here because there should not be
         # too many system_libpaths to cause library version issues.
-        pkg_config_path = self.env.coredata.optstore.get_value_safe(OptionKey('pkg_config_path', machine=self.for_machine), list)
+        pkg_config_path = self.env.coredata.optstore.get_value(OptionKey('pkg_config_path', machine=self.for_machine), list)
         pkg_config_path = self._convert_mingw_paths(pkg_config_path)
         prefix_libpaths = OrderedSet(sort_libpaths(list(prefix_libpaths), pkg_config_path))
         system_libpaths: OrderedSet[str] = OrderedSet()
diff --git a/mesonbuild/dependencies/python.py b/mesonbuild/dependencies/python.py
index d24bcbc9ad3e..1775d145ea8b 100644
--- a/mesonbuild/dependencies/python.py
+++ b/mesonbuild/dependencies/python.py
@@ -251,7 +251,7 @@ def get_windows_link_args(self, limited_api: bool) -> T.Optional[T.List[str]]:
                     is_debug_build = debug or buildtype == 'debug'
                     vscrt_debug = False
                     if OptionKey('b_vscrt') in self.env.coredata.optstore:
-                        vscrt = self.env.coredata.optstore.get_value_safe('b_vscrt', str)
+                        vscrt = self.env.coredata.optstore.get_value('b_vscrt', str)
                         if vscrt in {'mdd', 'mtd', 'from_buildtype', 'static_from_buildtype'}:
                             vscrt_debug = True
                     if is_debug_build and vscrt_debug and not self.variables.get('Py_DEBUG'):
diff --git a/mesonbuild/dependencies/qt.py b/mesonbuild/dependencies/qt.py
index 07f0b4ad97ea..7cd22664f2c4 100644
--- a/mesonbuild/dependencies/qt.py
+++ b/mesonbuild/dependencies/qt.py
@@ -298,7 +298,7 @@ def __init__(self, name: str, env: 'Environment', kwargs: T.Dict[str, T.Any]):
         # Use the buildtype by default, but look at the b_vscrt option if the
         # compiler supports it.
         is_debug = self.env.coredata.get_option(OptionKey('buildtype')) == 'debug'
-        if self.env.coredata.optstore.get_value_safe('b_vscrt', str, '') in {'mdd', 'mtd'}:
+        if self.env.coredata.optstore.get_value('b_vscrt', str, '') in {'mdd', 'mtd'}:
             is_debug = True
         modules_lib_suffix = _get_modules_lib_suffix(self.version, self.env.machines[self.for_machine], is_debug)
 
diff --git a/mesonbuild/interpreter/interpreter.py b/mesonbuild/interpreter/interpreter.py
index 33ac74e2c188..ea9393fecab1 100644
--- a/mesonbuild/interpreter/interpreter.py
+++ b/mesonbuild/interpreter/interpreter.py
@@ -1023,7 +1023,7 @@ def _do_subproject_cmake(self, subp_name: str, subdir: str,
                              kwargs: kwtypes.DoSubproject) -> SubprojectHolder:
         from ..cmake import CMakeInterpreter
         with mlog.nested(subp_name):
-            prefix = self.coredata.optstore.get_value_safe('prefix', str)
+            prefix = self.coredata.optstore.get_value('prefix', str)
 
             from ..modules.cmake import CMakeSubprojectOptions
             options = kwargs.get('options') or CMakeSubprojectOptions()
@@ -3112,9 +3112,9 @@ def check_clang_asan_lundef(self) -> None:
             return
         if OptionKey('b_sanitize') not in self.coredata.optstore:
             return
-        if (self.coredata.optstore.get_value_safe('b_lundef', bool) and
-                self.coredata.optstore.get_value_safe('b_sanitize', str) != 'none'):
-            value = self.coredata.optstore.get_value_safe('b_sanitize', str)
+        if (self.coredata.optstore.get_value('b_lundef', bool) and
+                self.coredata.optstore.get_value('b_sanitize', str) != 'none'):
+            value = self.coredata.optstore.get_value('b_sanitize', str)
             mlog.warning(textwrap.dedent(f'''\
                     Trying to use {value} sanitizer on Clang with b_lundef.
                     This will probably not work.
diff --git a/mesonbuild/modules/gnome.py b/mesonbuild/modules/gnome.py
index 55bc2e61ec15..20724d640e99 100644
--- a/mesonbuild/modules/gnome.py
+++ b/mesonbuild/modules/gnome.py
@@ -910,7 +910,7 @@ def _get_langs_compilers_flags(state: 'ModuleState', langs_compilers: T.List[T.T
             if state.project_args.get(lang):
                 cflags += state.project_args[lang]
             if OptionKey('b_sanitize') in compiler.base_options:
-                sanitize_ = state.environment.coredata.optstore.get_value_safe('b_sanitize', str)
+                sanitize_ = state.environment.coredata.optstore.get_value('b_sanitize', str)
                 cflags += compiler.sanitizer_compile_args(sanitize_)
                 sanitize = sanitize_.split(',')
                 # These must be first in ldflags
diff --git a/mesonbuild/modules/python.py b/mesonbuild/modules/python.py
index 91dad82f1d4b..2fed1773c31b 100644
--- a/mesonbuild/modules/python.py
+++ b/mesonbuild/modules/python.py
@@ -208,7 +208,7 @@ def extension_module_method(self, args: T.Tuple[str, T.List[BuildTargetSource]],
 
                 new_link_args = mesonlib.extract_as_list(kwargs, 'link_args')
 
-                is_debug = self.interpreter.environment.coredata.optstore.get_value_safe('debug', bool)
+                is_debug = self.interpreter.environment.coredata.optstore.get_value('debug', bool)
                 if is_debug:
                     new_link_args.append(python_windows_debug_link_exception)
                 else:
diff --git a/mesonbuild/msetup.py b/mesonbuild/msetup.py
index 608476efd4e9..10c711baece6 100644
--- a/mesonbuild/msetup.py
+++ b/mesonbuild/msetup.py
@@ -275,9 +275,9 @@ def _generate(self, env: environment.Environment, capture: bool, vslite_ctx: T.O
 
             # collect warnings about unsupported build configurations; must be done after full arg processing
             # by Interpreter() init, but this is most visible at the end
-            if env.coredata.optstore.get_value_safe('backend', str) == 'xcode':
+            if env.coredata.optstore.get_value('backend', str) == 'xcode':
                 mlog.warning('xcode backend is currently unmaintained, patches welcome')
-            if env.coredata.optstore.get_value_safe('layout', str) == 'flat':
+            if env.coredata.optstore.get_value('layout', str) == 'flat':
                 mlog.warning('-Dlayout=flat is unsupported and probably broken. It was a failed experiment at '
                              'making Windows build artifacts runnable while uninstalled, due to PATH considerations, '
                              'but was untested by CI and anyways breaks reasonable use of conflicting targets in different subdirs. '
diff --git a/mesonbuild/options.py b/mesonbuild/options.py
index c538709182de..725dbcfe1016 100644
--- a/mesonbuild/options.py
+++ b/mesonbuild/options.py
@@ -757,13 +757,13 @@ def ensure_key(self, key: T.Union[OptionKey, str]) -> OptionKey:
     def get_value_object(self, key: T.Union[OptionKey, str]) -> AnyOptionType:
         return self.d[self.ensure_key(key)]
 
-    def get_value(self, key: T.Union[OptionKey, str]) -> ElementaryOptionValues:
+    def get_value_unsafe(self, key: T.Union[OptionKey, str]) -> ElementaryOptionValues:
         return self.get_value_object(key).value
 
-    def get_value_safe(self, key: T.Union[OptionKey, str],
-                       type_: T.Type[ElementaryOptionTypes],
-                       fallback: T.Optional[ElementaryOptionTypes] = None,
-                       ) -> ElementaryOptionTypes:
+    def get_value(self, key: T.Union[OptionKey, str],
+                  type_: T.Type[ElementaryOptionTypes],
+                  fallback: T.Optional[ElementaryOptionTypes] = None,
+                  ) -> ElementaryOptionTypes:
         try:
             v = self.get_value_object(key).value
             assert isinstance(v, type_), 'for mypy'
diff --git a/unittests/allplatformstests.py b/unittests/allplatformstests.py
index 40d02eda8967..233ab43139e0 100644
--- a/unittests/allplatformstests.py
+++ b/unittests/allplatformstests.py
@@ -2625,35 +2625,35 @@ def test_command_line(self):
         out = self.init(testdir, extra_args=['--profile-self', '--fatal-meson-warnings'])
         self.assertNotIn('[default: true]', out)
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('default_library', str), 'static')
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '1')
-        self.assertEqual(obj.optstore.get_value_safe('set_sub_opt', bool), True)
-        self.assertEqual(obj.optstore.get_value_safe(OptionKey('subp_opt', 'subp'), str), 'default3')
+        self.assertEqual(obj.optstore.get_value('default_library', str), 'static')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '1')
+        self.assertEqual(obj.optstore.get_value('set_sub_opt', bool), True)
+        self.assertEqual(obj.optstore.get_value(OptionKey('subp_opt', 'subp'), str), 'default3')
         self.wipe()
 
         # warning_level is special, it's --warnlevel instead of --warning-level
         # for historical reasons
         self.init(testdir, extra_args=['--warnlevel=2', '--fatal-meson-warnings'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '2')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '2')
         self.setconf('--warnlevel=3')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '3')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '3')
         self.setconf('--warnlevel=everything')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), 'everything')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), 'everything')
         self.wipe()
 
         # But when using -D syntax, it should be 'warning_level'
         self.init(testdir, extra_args=['-Dwarning_level=2', '--fatal-meson-warnings'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '2')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '2')
         self.setconf('-Dwarning_level=3')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '3')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '3')
         self.setconf('-Dwarning_level=everything')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), 'everything')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), 'everything')
         self.wipe()
 
         # Mixing --option and -Doption is forbidden
@@ -2677,15 +2677,15 @@ def test_command_line(self):
         # --default-library should override default value from project()
         self.init(testdir, extra_args=['--default-library=both', '--fatal-meson-warnings'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('default_library', str), 'both')
+        self.assertEqual(obj.optstore.get_value('default_library', str), 'both')
         self.setconf('--default-library=shared')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('default_library', str), 'shared')
+        self.assertEqual(obj.optstore.get_value('default_library', str), 'shared')
         if self.backend is Backend.ninja:
             # reconfigure target works only with ninja backend
             self.build('reconfigure')
             obj = mesonbuild.coredata.load(self.builddir)
-            self.assertEqual(obj.optstore.get_value_safe('default_library', str), 'shared')
+            self.assertEqual(obj.optstore.get_value('default_library', str), 'shared')
         self.wipe()
 
         # Should fail on unknown options
@@ -2722,22 +2722,22 @@ def test_command_line(self):
         # Test we can set subproject option
         self.init(testdir, extra_args=['-Dsubp:subp_opt=foo', '--fatal-meson-warnings'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe(OptionKey('subp_opt', 'subp'), str), 'foo')
+        self.assertEqual(obj.optstore.get_value(OptionKey('subp_opt', 'subp'), str), 'foo')
         self.wipe()
 
         # c_args value should be parsed with split_args
         self.init(testdir, extra_args=['-Dc_args=-Dfoo -Dbar "-Dthird=one two"', '--fatal-meson-warnings'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe(OptionKey('c_args'), list), ['-Dfoo', '-Dbar', '-Dthird=one two'])
+        self.assertEqual(obj.optstore.get_value(OptionKey('c_args'), list), ['-Dfoo', '-Dbar', '-Dthird=one two'])
 
         self.setconf('-Dc_args="foo bar" one two')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe(OptionKey('c_args'), list), ['foo bar', 'one', 'two'])
+        self.assertEqual(obj.optstore.get_value(OptionKey('c_args'), list), ['foo bar', 'one', 'two'])
         self.wipe()
 
         self.init(testdir, extra_args=['-Dset_percent_opt=myoption%', '--fatal-meson-warnings'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('set_percent_opt', str), 'myoption%')
+        self.assertEqual(obj.optstore.get_value('set_percent_opt', str), 'myoption%')
         self.wipe()
 
         # Setting a 2nd time the same option should override the first value
@@ -2748,19 +2748,19 @@ def test_command_line(self):
                                            '-Dc_args=-Dfoo', '-Dc_args=-Dbar',
                                            '-Db_lundef=false', '--fatal-meson-warnings'])
             obj = mesonbuild.coredata.load(self.builddir)
-            self.assertEqual(obj.optstore.get_value_safe('bindir', str), 'bar')
-            self.assertEqual(obj.optstore.get_value_safe('buildtype', str), 'release')
-            self.assertEqual(obj.optstore.get_value_safe('b_sanitize', str), 'thread')
-            self.assertEqual(obj.optstore.get_value_safe(OptionKey('c_args'), list), ['-Dbar'])
+            self.assertEqual(obj.optstore.get_value('bindir', str), 'bar')
+            self.assertEqual(obj.optstore.get_value('buildtype', str), 'release')
+            self.assertEqual(obj.optstore.get_value('b_sanitize', str), 'thread')
+            self.assertEqual(obj.optstore.get_value(OptionKey('c_args'), list), ['-Dbar'])
             self.setconf(['--bindir=bar', '--bindir=foo',
                           '-Dbuildtype=release', '-Dbuildtype=plain',
                           '-Db_sanitize=thread', '-Db_sanitize=address',
                           '-Dc_args=-Dbar', '-Dc_args=-Dfoo'])
             obj = mesonbuild.coredata.load(self.builddir)
-            self.assertEqual(obj.optstore.get_value_safe('bindir', str), 'foo')
-            self.assertEqual(obj.optstore.get_value_safe('buildtype', str), 'plain')
-            self.assertEqual(obj.optstore.get_value_safe('b_sanitize', str), 'address')
-            self.assertEqual(obj.optstore.get_value_safe(OptionKey('c_args'), list), ['-Dfoo'])
+            self.assertEqual(obj.optstore.get_value('bindir', str), 'foo')
+            self.assertEqual(obj.optstore.get_value('buildtype', str), 'plain')
+            self.assertEqual(obj.optstore.get_value('b_sanitize', str), 'address')
+            self.assertEqual(obj.optstore.get_value(OptionKey('c_args'), list), ['-Dfoo'])
             self.wipe()
         except KeyError:
             # Ignore KeyError, it happens on CI for compilers that does not
@@ -2774,25 +2774,25 @@ def test_warning_level_0(self):
         # Verify default values when passing no args
         self.init(testdir)
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '0')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '0')
         self.wipe()
 
         # verify we can override w/ --warnlevel
         self.init(testdir, extra_args=['--warnlevel=1'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '1')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '1')
         self.setconf('--warnlevel=0')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '0')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '0')
         self.wipe()
 
         # verify we can override w/ -Dwarning_level
         self.init(testdir, extra_args=['-Dwarning_level=1'])
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '1')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '1')
         self.setconf('-Dwarning_level=0')
         obj = mesonbuild.coredata.load(self.builddir)
-        self.assertEqual(obj.optstore.get_value_safe('warning_level', str), '0')
+        self.assertEqual(obj.optstore.get_value('warning_level', str), '0')
         self.wipe()
 
     def test_feature_check_usage_subprojects(self):
diff --git a/unittests/datatests.py b/unittests/datatests.py
index a7e6251c1cfb..e2cb96faa55e 100644
--- a/unittests/datatests.py
+++ b/unittests/datatests.py
@@ -162,9 +162,9 @@ def test_builtin_options_documented(self):
             else:
                 raise RuntimeError(f'Invalid debug value {debug!r} in row:\n{m.group()}')
             env.coredata.set_option(OptionKey('buildtype'), buildtype)
-            self.assertEqual(env.coredata.optstore.get_value_safe('buildtype', str), buildtype)
-            self.assertEqual(env.coredata.optstore.get_value_safe('optimization', str), opt)
-            self.assertEqual(env.coredata.optstore.get_value_safe('debug', bool), debug)
+            self.assertEqual(env.coredata.optstore.get_value('buildtype', str), buildtype)
+            self.assertEqual(env.coredata.optstore.get_value('optimization', str), opt)
+            self.assertEqual(env.coredata.optstore.get_value('debug', bool), debug)
 
     def test_cpu_families_documented(self):
         with open("docs/markdown/Reference-tables.md", encoding='utf-8') as f:
diff --git a/unittests/linuxliketests.py b/unittests/linuxliketests.py
index 9977d402ff96..d678b5e62009 100644
--- a/unittests/linuxliketests.py
+++ b/unittests/linuxliketests.py
@@ -1138,7 +1138,7 @@ def test_pkgconfig_duplicate_path_entries(self):
         # option, adding the meson-uninstalled directory to it.
         PkgConfigInterface.setup_env({}, env, MachineChoice.HOST, uninstalled=True)
 
-        pkg_config_path = env.coredata.optstore.get_value_safe('pkg_config_path', list)
+        pkg_config_path = env.coredata.optstore.get_value('pkg_config_path', list)
         self.assertEqual(pkg_config_path, [pkg_dir])
 
     def test_pkgconfig_uninstalled_env_added(self):