options: fix option ordering

Signed-off-by: Paolo Bonzini <[email protected]>

Author: bonzini

mesonbuild/interpreter/interpreter.py

@@ -1207,7 +1207,8 @@ def func_project(self, node: mparser.FunctionNode, args: T.Tuple[str, T.List[str
                 self.coredata.optstore.initialize_from_subproject_call(self.subproject,
                                                                        self.invoker_method_default_options,
                                                                        self.project_default_options,
-                                                                       self.user_defined_options.cmd_line_options)
+                                                                       self.user_defined_options.cmd_line_options,
+                                                                       self.environment.options)
                 self.coredata.initialized_subprojects.add(self.subproject)
 
         if not self.is_subproject():

mesonbuild/options.py

@@ -1305,30 +1305,31 @@ def initialize_from_top_level_project_call(self,
             if not self.is_cross and key.is_for_build():
                 continue
             if key.subproject:
-                self.augments[key] = valstr
+                # do apply project() default_options for subprojects here, because
+                # they have low priority
+                self.pending_options[key] = valstr
             else:
                 # Setting a project option with default_options
                 # should arguably be a hard error; the default
                 # value of project option should be set in the option
                 # file, not in the project call.
                 self.set_option_maybe_root(key, valstr, True)
+
+        # ignore subprojects for now for machine file and command line
+        # options; they are applied later
         for key, valstr in machine_file_options.items():
             # Due to backwards compatibility we ignore all build-machine options
             # when building natively.
             if not self.is_cross and key.is_for_build():
                 continue
-            if key.subproject:
-                self.augments[key] = valstr
-            else:
+            if not key.subproject:
                 self.set_option_maybe_root(key, valstr, True)
         for key, valstr in cmd_line_options.items():
             # Due to backwards compatibility we ignore all build-machine options
             # when building natively.
             if not self.is_cross and key.is_for_build():
                 continue
-            if key.subproject:
-                self.augments[key] = valstr
-            else:
+            if not key.subproject:
                 self.set_option_maybe_root(key, valstr, True)
 
     def accept_as_pending_option(self, key: OptionKey, known_subprojects: T.Optional[T.Container[str]] = None,
@@ -1362,26 +1363,37 @@ def initialize_from_subproject_call(self,
                                         subproject: str,
                                         spcall_default_options: OptionDict,
                                         project_default_options: OptionDict,
-                                        cmd_line_options: OptionDict) -> None:
+                                        cmd_line_options: OptionDict,
+                                        machine_file_options: OptionDict) -> None:
+        # pick up pending per-project settings from the toplevel project() invocation
+        options = {k: v for k, v in self.pending_options.items() if k.subproject == subproject}
+
+        # apply project() and subproject() default_options
         for key, valstr in itertools.chain(project_default_options.items(), spcall_default_options.items()):
             if key.subproject is None:
                 key = key.evolve(subproject=subproject)
             elif key.subproject == subproject:
                 without_subp = key.evolve(subproject=None)
                 raise MesonException(f'subproject name not needed in default_options; use "{without_subp}" instead of "{key}"')
-            # If the key points to a project option, set the value from that.
-            # Otherwise set an augment.
-            if key in self.project_options:
-                self.set_option(key, valstr, True)
-            else:
-                self.pending_options.pop(key, None)
-                self.augments[key] = valstr
-        # Check for pending options
-        for key, valstr in cmd_line_options.items():
-            if key.subproject != subproject:
-                continue
+            options[key] = valstr
+
+        # then global settings from machine file and command line
+        for key, valstr in itertools.chain(machine_file_options.items(), cmd_line_options.items()):
+            if key.subproject is None:
+                subp_key = key.evolve(subproject=subproject)
+                self.pending_options.pop(subp_key, None)
+                options.pop(subp_key, None)
+
+        # then finally per project augments from machine file and command line
+        for key, valstr in itertools.chain(machine_file_options.items(), cmd_line_options.items()):
+            if key.subproject == subproject:
+                options[key] = valstr
+
+        # merge everything that has been computed above, while giving self.augments priority
+        for key, valstr in options.items():
             self.pending_options.pop(key, None)
-            if key in self.options:
+            valstr = self.augments.pop(key, valstr)
+            if key in self.project_options:
                 self.set_option(key, valstr, True)
             else:
                 self.augments[key] = valstr

unittests/machinefiletests.py

@@ -563,12 +563,18 @@ def test_builtin_options_machinefile_overrides_subproject(self):
                 check = cm.exception.stdout
             self.assertIn(check, 'Parent should override default_library')
 
-    def test_builtin_options_machinefile_global_loses_over_subproject(self):
-        # The buildfile says subproject(... default_library: static), ensure that it overrides the machinefile
-        # FIXME: Should it??
+    def test_builtin_options_machinefile_global_overrides_subproject(self):
+        # The buildfile says subproject(... default_library: static), ensure that's overridden
         testcase = os.path.join(self.common_test_dir, '223 persubproject options')
         config = self.helper_create_native_file({'built-in options': {'default_library': 'both'}})
-        self.init(testcase, extra_args=['--native-file', config])
+
+        with self.assertRaises((RuntimeError, subprocess.CalledProcessError)) as cm:
+            self.init(testcase, extra_args=['--native-file', config])
+            if isinstance(cm, RuntimeError):
+                check = str(cm.exception)
+            else:
+                check = cm.exception.stdout
+            self.assertIn(check, 'Parent should override default_library')
 
     def test_builtin_options_compiler_properties(self):
         # the properties section can have lang_args, and those need to be

unittests/optiontests.py

@@ -240,6 +240,68 @@ def test_subproject_nonexistent(self):
         self.assertFalse(optstore.accept_as_pending_option(OptionKey('foo', subproject='found'), subprojects))
         self.assertTrue(optstore.accept_as_pending_option(OptionKey('foo', subproject='whatisthis'), subprojects))
 
+    def test_subproject_cmdline_override_global(self):
+        name = 'optimization'
+        subp = 'subp'
+        new_value = '0'
+
+        optstore = OptionStore(False)
+        prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr')
+        optstore.add_system_option('prefix', prefix)
+        o = UserComboOption(name, 'Optimization level', '0', choices=['plain', '0', 'g', '1', '2', '3', 's'])
+        optstore.add_system_option(name, o)
+
+        toplevel_proj_default = {OptionKey(name): 's'}
+        subp_proj_default = {OptionKey(name): '3'}
+        cmd_line = {OptionKey(name): new_value}
+
+        optstore.initialize_from_top_level_project_call(toplevel_proj_default, cmd_line, {})
+        optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, cmd_line, {})
+        self.assertEqual(optstore.get_value_for(name, subp), new_value)
+        self.assertEqual(optstore.get_value_for(name), new_value)
+
+    def test_subproject_cmdline_override_global_and_augment(self):
+        name = 'optimization'
+        subp = 'subp'
+        global_value = 's'
+        new_value = '0'
+
+        optstore = OptionStore(False)
+        prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr')
+        optstore.add_system_option('prefix', prefix)
+        o = UserComboOption(name, 'Optimization level', '0', choices=['plain', '0', 'g', '1', '2', '3', 's'])
+        optstore.add_system_option(name, o)
+
+        toplevel_proj_default = {OptionKey(name): '1'}
+        subp_proj_default = {OptionKey(name): '3'}
+        cmd_line = {OptionKey(name): global_value, OptionKey(name, subproject=subp): new_value}
+
+        optstore.initialize_from_top_level_project_call(toplevel_proj_default, cmd_line, {})
+        optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, cmd_line, {})
+        self.assertEqual(optstore.get_value_for(name, subp), new_value)
+        self.assertEqual(optstore.get_value_for(name), global_value)
+
+    def test_subproject_cmdline_override_toplevel(self):
+        name = 'default_library'
+        subp = 'subp'
+        toplevel_value = 'both'
+        subp_value = 'static'
+
+        optstore = OptionStore(False)
+        prefix = UserStringOption('prefix', 'This is needed by OptionStore', '/usr')
+        optstore.add_system_option('prefix', prefix)
+        o = UserComboOption(name, 'Kind of library', 'both', choices=['shared', 'static', 'both'])
+        optstore.add_system_option(name, o)
+
+        toplevel_proj_default = {OptionKey(name): 'shared'}
+        subp_proj_default = {OptionKey(name): subp_value}
+        cmd_line = {OptionKey(name, subproject=''): toplevel_value}
+
+        optstore.initialize_from_top_level_project_call(toplevel_proj_default, cmd_line, {})
+        optstore.initialize_from_subproject_call(subp, {}, subp_proj_default, cmd_line, {})
+        self.assertEqual(optstore.get_value_for(name, subp), subp_value)
+        self.assertEqual(optstore.get_value_for(name), toplevel_value)
+
     def test_deprecated_nonstring_value(self):
         # TODO: add a lot more deprecated option tests
         optstore = OptionStore(False)