subproject: Fix inheritance of language options

Add handling of language args for subprojects, which was
previously only done for the main project as part of the detection
of the language compiler.

Language options were deferred for later handling during
language load. This caused default language options to break for
subprojects which were missing this loading step.

Resolves #13260.

Signed-off-by: Eyal Itkin <eyal.itkin@gmail.com>

mesonbuild/ast/introspection.py

@@ -197,11 +197,16 @@ def _add_languages(self, raw_langs: T.List[TYPE_var], required: bool, for_machin
                         continue
                 if self.subproject:
                     options = {}
+                    lang_options = compilers.compilers.get_global_options(lang, type(comp), for_machine, self.environment)
+                    for k in lang_options:
+                        v = copy.copy(self.coredata.optstore.get_value_object(k))
+                        k = k.evolve(subproject=self.subproject)
+                        options[k] = v
                     for k in comp.get_options():
                         v = copy.copy(self.coredata.optstore.get_value_object(k))
                         k = k.evolve(subproject=self.subproject)
                         options[k] = v
-                    self.coredata.add_compiler_options(options, lang, for_machine, self.environment, self.subproject)
+                    self.coredata.add_compiler_options(options, for_machine, self.environment, self.subproject)
 
     def func_dependency(self, node: BaseNode, args: T.List[TYPE_var], kwargs: T.Dict[str, TYPE_var]) -> None:
         args = self.flatten_args(args)

mesonbuild/compilers/detect.py

@@ -106,7 +106,7 @@ def detect_compiler_for(env: 'Environment', lang: str, for_machine: MachineChoic
     if comp is None:
         return comp
     assert comp.for_machine == for_machine
-    env.coredata.process_compiler_options(lang, comp, env, subproject)
+    env.coredata.process_compiler_options(comp, env, subproject)
     if not skip_sanity_check:
         comp.sanity_check(env.get_scratch_dir(), env)
     env.coredata.compilers[comp.for_machine][lang] = comp

mesonbuild/coredata.py

@@ -710,7 +710,7 @@ def set_default_options(self, default_options: T.MutableMapping[OptionKey, str],
 
         self.set_options(options, subproject=subproject, first_invocation=env.first_invocation)
 
-    def add_compiler_options(self, c_options: MutableKeyedOptionDictType, lang: str, for_machine: MachineChoice,
+    def add_compiler_options(self, c_options: MutableKeyedOptionDictType, for_machine: MachineChoice,
                              env: Environment, subproject: str) -> None:
         for k, o in c_options.items():
             value = env.options.get(k)
@@ -738,10 +738,10 @@ def add_lang_args(self, lang: str, comp: T.Type['Compiler'],
         for gopt_key, gopt_valobj in compilers.get_global_options(lang, comp, for_machine, env).items():
             self.optstore.add_compiler_option(lang, gopt_key, gopt_valobj)
 
-    def process_compiler_options(self, lang: str, comp: Compiler, env: Environment, subproject: str) -> None:
+    def process_compiler_options(self, comp: Compiler, env: Environment, subproject: str) -> None:
         from . import compilers
 
-        self.add_compiler_options(comp.get_options(), lang, comp.for_machine, env, subproject)
+        self.add_compiler_options(comp.get_options(), comp.for_machine, env, subproject)
 
         enabled_opts: T.List[OptionKey] = []
         for key in comp.base_options:

mesonbuild/interpreter/interpreter.py

@@ -1538,16 +1538,22 @@ def add_languages_for(self, args: T.List[str], required: bool, for_machine: Mach
                     self.backend.allow_thin_archives[for_machine] = False
             else:
                 # update new values from commandline, if it applies
-                self.coredata.process_compiler_options(lang, comp, self.environment, self.subproject)
+                self.coredata.process_compiler_options(comp, self.environment, self.subproject)
 
-            # Add per-subproject compiler options. They inherit value from main project.
+            # Add per-subproject language and compiler options. They inherit value from main project.
             if self.subproject:
                 options = {}
+                lang_options = compilers.compilers.get_global_options(lang, type(comp), for_machine, self.environment)
+                for k in lang_options:
+                    v = copy.copy(self.coredata.optstore.get_value_object(k))
+                    k = k.evolve(subproject=self.subproject)
+                    options[k] = v
+
                 for k in comp.get_options():
                     v = copy.copy(self.coredata.optstore.get_value_object(k))
                     k = k.evolve(subproject=self.subproject)
                     options[k] = v
-                self.coredata.add_compiler_options(options, lang, for_machine, self.environment, self.subproject)
+                self.coredata.add_compiler_options(options, for_machine, self.environment, self.subproject)
 
             if for_machine == MachineChoice.HOST or self.environment.is_cross_build():
                 logger_fun = mlog.log

run_project_tests.py

@@ -990,7 +990,7 @@ def have_working_compiler(lang: str, use_tmp: bool) -> bool:
             return False
         if not compiler:
             return False
-        env.coredata.process_compiler_options(lang, compiler, env, '')
+        env.coredata.process_compiler_options(compiler, env, '')
         try:
             compiler.sanity_check(env.get_scratch_dir(), env)
         except mesonlib.MesonException:

test cases/common/87 default options/meson.build

@@ -30,4 +30,6 @@ assert(w_level == '3', 'warning level "' + w_level + '" instead of "3"')
 #   assert(cc.compiles('int foobar;', no_builtin_args : true), 'No_builtin did not disable builtins.')
 # endif
 
-subproject('sub1')
+subproject('sub1', default_options : [
+  'c_args=-Dtest',
+  ])

test cases/common/87 default options/subprojects/sub1/meson.build

@@ -1,3 +1,4 @@
-project('sub1')
+project('sub1', 'c')
 
 assert(get_option('test_option') == false)
+assert(get_option('c_args') == ['-Dtest'])

unittests/machinefiletests.py

@@ -523,20 +523,21 @@ def test_builtin_options_subprojects(self):
 
         self.init(testcase, extra_args=['--native-file', config])
         configuration = self.introspect('--buildoptions')
-        found = 0
+        score = 0
         for each in configuration:
             # Test that no-per subproject options are inherited from the parent
+            # while the rest of the options are inherited as-is
             if 'c_args' in each['name']:
-                # This path will be hit twice, once for build and once for host,
+                # This path will be hit twice per project: for build and for host
                 self.assertEqual(each['value'], ['-Dfoo'])
-                found += 1
+                score += 1
             elif each['name'] == 'default_library':
                 self.assertEqual(each['value'], 'both')
-                found += 1
+                score += 10
             elif each['name'] == 'sub:default_library':
                 self.assertEqual(each['value'], 'static')
-                found += 1
-        self.assertEqual(found, 4, 'Did not find all three sections')
+                score += 100
+        self.assertEqual(score, 118, 'Did not find all three sections')
 
     def test_builtin_options_subprojects_overrides_buildfiles(self):
         # If the buildfile says subproject(... default_library: shared), ensure that's overwritten