compilers: move CFLAGS/CXXFLAGS handling to Environment

That is where env_opts are stored, so make the compiler call back directly
into the environment.

Suggested-by: Dylan Baker <dylan@pnwbakers.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>

5 files changed, 74 insertions, 83 deletions

diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py
index 057868f7a..af6b05015 100644
--- a/mesonbuild/compilers/compilers.py
+++ b/mesonbuild/compilers/compilers.py
@@ -1417,47 +1417,3 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta):
         if 'none' not in value:
             value = ['none'] + value
         std.choices = value
-
-
-def add_global_options(lang: str,
-                       comp: T.Type[Compiler],
-                       for_machine: MachineChoice,
-                       env: 'Environment'):
-    """Retrieve options that apply to all compilers for a given language."""
-    description = f'Extra arguments passed to the {lang}'
-    argkey = OptionKey(f'{lang}_args', machine=for_machine)
-    largkey = OptionKey(f'{lang}_link_args', machine=for_machine)
-
-    comp_args_from_envvar = False
-    comp_options = env.coredata.optstore.get_pending_value(argkey)
-    if comp_options is None:
-        comp_args_from_envvar = True
-        comp_options = env.env_opts.get(argkey, [])
-
-    link_options = env.coredata.optstore.get_pending_value(largkey)
-    if link_options is None:
-        link_options = env.env_opts.get(largkey, [])
-
-    assert isinstance(comp_options, (str, list)), 'for mypy'
-    assert isinstance(link_options, (str, list)), 'for mypy'
-
-    cargs = options.UserStringArrayOption(
-        argkey.name,
-        description + ' compiler',
-        comp_options, split_args=True, allow_dups=True)
-
-    largs = options.UserStringArrayOption(
-        largkey.name,
-        description + ' linker',
-        link_options, split_args=True, allow_dups=True)
-
-    env.coredata.optstore.add_compiler_option(lang, argkey, cargs)
-    env.coredata.optstore.add_compiler_option(lang, largkey, largs)
-
-    if comp.INVOKES_LINKER and comp_args_from_envvar:
-        # If the compiler acts as a linker driver, and we're using the
-        # environment variable flags for both the compiler and linker
-        # arguments, then put the compiler flags in the linker flags as well.
-        # This is how autotools works, and the env vars feature is for
-        # autotools compatibility.
-        largs.extend_value(comp_options)
diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py
index 040c42f6c..f57957f0b 100644
--- a/mesonbuild/compilers/detect.py
+++ b/mesonbuild/compilers/detect.py
@@ -366,7 +366,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
 
         if 'Emscripten' in out:
             cls = c.EmscriptenCCompiler if lang == 'c' else cpp.EmscriptenCPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
 
             # emcc requires a file input in order to pass arguments to the
             # linker. It'll exit with an error code, but still print the
@@ -410,7 +410,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             full_version = arm_ver_str
             cls = c.ArmclangCCompiler if lang == 'c' else cpp.ArmclangCPPCompiler
             linker = linkers.ArmClangDynamicLinker(for_machine, version=version)
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             return cls(
                 ccache, compiler, version, for_machine, is_cross, info,
                 full_version=full_version, linker=linker)
@@ -445,7 +445,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             if identifier in out:
                 cls = compiler_classes[0] if lang == 'c' else compiler_classes[1]
                 lnk = compiler_classes[2]
-                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                env.add_lang_args(cls.language, cls, for_machine)
                 linker = lnk(compiler, for_machine, version=version)
                 return cls(
                     ccache, compiler, version, for_machine, is_cross, info,
@@ -482,7 +482,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             version = search_version(err)
             target = 'x86' if 'IA-32' in err else 'x86_64'
             cls = c.IntelClCCompiler if lang == 'c' else cpp.IntelClCPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
             return cls(
                 compiler, version, for_machine, is_cross, info, target,
@@ -491,7 +491,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             version = search_version(err)
             target = 'x86' if 'IA-32' in err else 'x86_64'
             cls = c.IntelLLVMClCCompiler if lang == 'c' else cpp.IntelLLVMClCPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
             return cls(
                 compiler, version, for_machine, is_cross, info, target,
@@ -524,14 +524,14 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 full_version=cl_signature, linker=linker)
         if 'PGI Compilers' in out:
             cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
                 info, linker=linker)
         if 'NVIDIA Compilers and Tools' in out:
             cls = c.NvidiaHPC_CCompiler if lang == 'c' else cpp.NvidiaHPC_CPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
@@ -550,14 +550,14 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 full_version=full_version, linker=l)
         if 'ARM' in out and not ('Metrowerks' in out or 'Freescale' in out):
             cls = c.ArmCCompiler if lang == 'c' else cpp.ArmCPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.ArmDynamicLinker(for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
                 info, full_version=full_version, linker=linker)
         if 'RX Family' in out:
             cls = c.CcrxCCompiler if lang == 'c' else cpp.CcrxCPPCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.CcrxDynamicLinker(for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross, info,
@@ -565,7 +565,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
 
         if 'Microchip Technology' in out:
             cls = c.Xc16CCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.Xc16DynamicLinker(for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross, info,
@@ -573,7 +573,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
 
         if 'CompCert' in out:
             cls = c.CompCertCCompiler
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             linker = linkers.CompCertDynamicLinker(for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross, info,
@@ -591,7 +591,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             assert mwcc_ver_match is not None, 'for mypy'  # because mypy *should* be complaining that this could be None
             compiler_version = '.'.join(x for x in mwcc_ver_match.groups() if x is not None)
 
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             ld = env.lookup_binary_entry(for_machine, cls.language + '_ld')
 
             if ld is not None:
@@ -616,7 +616,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             assert tasking_ver_match is not None, 'for mypy'
             tasking_version = '.'.join(x for x in tasking_ver_match.groups() if x is not None)
 
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             ld = env.lookup_binary_entry(for_machine, cls.language + '_ld')
             if ld is None:
                 raise MesonException(f'{cls.language}_ld was not properly defined in your cross file')
@@ -668,7 +668,7 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
         version = out.strip().rsplit('V', maxsplit=1)[-1]
         cpp_compiler = detect_cpp_compiler(env, for_machine)
         cls = CudaCompiler
-        env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+        env.add_lang_args(cls.language, cls, for_machine)
         key = OptionKey('cuda_link_args', machine=for_machine)
         if key in env.options:
             # To fix LDFLAGS issue
@@ -759,7 +759,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 version = search_version(err)
                 target = 'x86' if 'IA-32' in err else 'x86_64'
                 cls = fortran.IntelLLVMClFortranCompiler
-                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                env.add_lang_args(cls.language, cls, for_machine)
                 linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
                 return cls(
                     compiler, version, for_machine, is_cross, info,
@@ -769,7 +769,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 version = search_version(err)
                 target = 'x86' if 'IA-32' in err else 'x86_64'
                 cls = fortran.IntelClFortranCompiler
-                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                env.add_lang_args(cls.language, cls, for_machine)
                 linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
                 return cls(
                     compiler, version, for_machine, is_cross, info,
@@ -796,7 +796,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
 
             if 'PGI Compilers' in out:
                 cls = fortran.PGIFortranCompiler
-                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                env.add_lang_args(cls.language, cls, for_machine)
                 linker = linkers.PGIDynamicLinker(compiler, for_machine,
                                                   cls.LINKER_PREFIX, [], version=version)
                 return cls(
@@ -805,7 +805,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
 
             if 'NVIDIA Compilers and Tools' in out:
                 cls = fortran.NvidiaHPC_FortranCompiler
-                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                env.add_lang_args(cls.language, cls, for_machine)
                 linker = linkers.PGIDynamicLinker(compiler, for_machine,
                                                   cls.LINKER_PREFIX, [], version=version)
                 return cls(
@@ -856,7 +856,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 full_version = err.split('\n', 1)[0]
                 version = full_version.split()[-1]
                 cls = fortran.NAGFortranCompiler
-                env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+                env.add_lang_args(cls.language, cls, for_machine)
                 linker = linkers.NAGDynamicLinker(
                     compiler, for_machine, cls.LINKER_PREFIX, [],
                     version=version)
@@ -948,7 +948,7 @@ def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
             if len(parts) > 1:
                 version = parts[1]
         comp_class = JavaCompiler
-        env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+        env.add_lang_args(comp_class.language, comp_class, for_machine)
         return comp_class(exelist, version, for_machine, info)
     raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
@@ -972,7 +972,7 @@ def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compil
             cls = cs.VisualStudioCsCompiler
         else:
             continue
-        env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+        env.add_lang_args(cls.language, cls, for_machine)
         return cls(comp, version, for_machine, info)
 
     _handle_exceptions(popen_exceptions, compilers)
@@ -1002,7 +1002,7 @@ def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Co
             version = search_version(err)
         if version is not None:
             comp_class = CythonCompiler
-            env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+            env.add_lang_args(comp_class.language, comp_class, for_machine)
             return comp_class([], comp, version, for_machine, info, is_cross=is_cross)
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
@@ -1023,7 +1023,7 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
     version = search_version(out)
     if 'Vala' in out:
         comp_class = ValaCompiler
-        env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+        env.add_lang_args(comp_class.language, comp_class, for_machine)
         return comp_class(exelist, version, for_machine, is_cross, info)
     raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
@@ -1145,7 +1145,7 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
                 c = linker.exelist[1] if linker.exelist[0].endswith('ccache') else linker.exelist[0]
                 compiler.extend(cls.use_linker_args(c, ''))
 
-            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            env.add_lang_args(cls.language, cls, for_machine)
             return cls(
                 compiler, version, for_machine, is_cross, info,
                 linker=linker, full_version=full_version)
@@ -1329,20 +1329,20 @@ def detect_nasm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
         version = search_version(output)
         if 'NASM' in output:
             comp_class = NasmCompiler
-            env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+            env.add_lang_args(comp_class.language, comp_class, for_machine)
             return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross)
         elif 'yasm' in output:
             comp_class = YasmCompiler
-            env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+            env.add_lang_args(comp_class.language, comp_class, for_machine)
             return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross)
         elif 'Metrowerks' in output or 'Freescale' in output:
             if 'ARM' in output:
                 comp_class_mwasmarm = MetrowerksAsmCompilerARM
-                env.coredata.add_lang_args(comp_class_mwasmarm.language, comp_class_mwasmarm, for_machine, env)
+                env.add_lang_args(comp_class_mwasmarm.language, comp_class_mwasmarm, for_machine)
                 return comp_class_mwasmarm([], comp, version, for_machine, info, cc.linker, is_cross=is_cross)
             else:
                 comp_class_mwasmeppc = MetrowerksAsmCompilerEmbeddedPowerPC
-                env.coredata.add_lang_args(comp_class_mwasmeppc.language, comp_class_mwasmeppc, for_machine, env)
+                env.add_lang_args(comp_class_mwasmeppc.language, comp_class_mwasmeppc, for_machine)
                 return comp_class_mwasmeppc([], comp, version, for_machine, info, cc.linker, is_cross=is_cross)
 
     _handle_exceptions(popen_exceptions, compilers)
@@ -1383,7 +1383,7 @@ def detect_masm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
     try:
         output = Popen_safe(comp + [arg])[2]
         version = search_version(output)
-        env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+        env.add_lang_args(comp_class.language, comp_class, for_machine)
         return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross)
     except OSError as e:
         popen_exceptions[' '.join(comp + [arg])] = e
@@ -1403,7 +1403,7 @@ def detect_linearasm_compiler(env: Environment, for_machine: MachineChoice) -> C
     try:
         output = Popen_safe(comp + [arg])[2]
         version = search_version(output)
-        env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+        env.add_lang_args(comp_class.language, comp_class, for_machine)
         return comp_class([], comp, version, for_machine, info, cc.linker, is_cross=is_cross)
     except OSError as e:
         popen_exceptions[' '.join(comp + [arg])] = e
diff --git a/mesonbuild/coredata.py b/mesonbuild/coredata.py
index 320b34b44..9a4139bed 100644
--- a/mesonbuild/coredata.py
+++ b/mesonbuild/coredata.py
@@ -38,7 +38,6 @@ if T.TYPE_CHECKING:
     from . import dependencies
     from .compilers.compilers import Compiler, CompileResult, RunResult, CompileCheckMode
     from .dependencies.detect import TV_DepID
-    from .environment import Environment
     from .mesonlib import FileOrString
     from .cmake.traceparser import CMakeCacheEntry
     from .interpreterbase import SubProject
@@ -584,12 +583,6 @@ class CoreData:
             else:
                 self.optstore.add_compiler_option(lang, k, o)
 
-    def add_lang_args(self, lang: str, comp: T.Type['Compiler'],
-                      for_machine: MachineChoice, env: 'Environment') -> None:
-        """Add global language arguments that are needed before compiler/linker detection."""
-        from .compilers import compilers
-        compilers.add_global_options(lang, comp, for_machine, env)
-
     def process_compiler_options(self, lang: str, comp: Compiler, subproject: str) -> None:
         self.add_compiler_options(comp.get_options(), lang, comp.for_machine)
 
diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
index 2c3bdecf3..2b79f02c0 100644
--- a/mesonbuild/environment.py
+++ b/mesonbuild/environment.py
@@ -12,6 +12,7 @@ import collections
 from . import coredata
 from . import mesonlib
 from . import machinefile
+from . import options
 
 CmdLineFileParser = machinefile.CmdLineFileParser
 
@@ -1071,3 +1072,44 @@ class Environment:
         if extra_paths:
             env.prepend('PATH', list(extra_paths))
         return env
+
+    def add_lang_args(self, lang: str, comp: T.Type['Compiler'],
+                      for_machine: MachineChoice) -> None:
+        """Add global language arguments that are needed before compiler/linker detection."""
+        description = f'Extra arguments passed to the {lang}'
+        argkey = OptionKey(f'{lang}_args', machine=for_machine)
+        largkey = OptionKey(f'{lang}_link_args', machine=for_machine)
+
+        comp_args_from_envvar = False
+        comp_options = self.coredata.optstore.get_pending_value(argkey)
+        if comp_options is None:
+            comp_args_from_envvar = True
+            comp_options = self.env_opts.get(argkey, [])
+
+        link_options = self.coredata.optstore.get_pending_value(largkey)
+        if link_options is None:
+            link_options = self.env_opts.get(largkey, [])
+
+        assert isinstance(comp_options, (str, list)), 'for mypy'
+        assert isinstance(link_options, (str, list)), 'for mypy'
+
+        cargs = options.UserStringArrayOption(
+            argkey.name,
+            description + ' compiler',
+            comp_options, split_args=True, allow_dups=True)
+
+        largs = options.UserStringArrayOption(
+            largkey.name,
+            description + ' linker',
+            link_options, split_args=True, allow_dups=True)
+
+        self.coredata.optstore.add_compiler_option(lang, argkey, cargs)
+        self.coredata.optstore.add_compiler_option(lang, largkey, largs)
+
+        if comp.INVOKES_LINKER and comp_args_from_envvar:
+            # If the compiler acts as a linker driver, and we're using the
+            # environment variable flags for both the compiler and linker
+            # arguments, then put the compiler flags in the linker flags as well.
+            # This is how autotools works, and the env vars feature is for
+            # autotools compatibility.
+            largs.extend_value(comp_options)
diff --git a/mesonbuild/linkers/detect.py b/mesonbuild/linkers/detect.py
index f4a2f7324..6fbe6e498 100644
--- a/mesonbuild/linkers/detect.py
+++ b/mesonbuild/linkers/detect.py
@@ -39,7 +39,7 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
                      use_linker_prefix: bool = True, invoked_directly: bool = True,
                      extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
     from . import linkers
-    env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+    env.add_lang_args(comp_class.language, comp_class, for_machine)
 
     if invoked_directly or comp_class.get_argument_syntax() == 'msvc':
         rsp_syntax = RSPFileSyntax.MSVC
@@ -128,7 +128,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
     :extra_args: Any additional arguments required (such as a source file)
     """
     from . import linkers
-    env.coredata.add_lang_args(comp_class.language, comp_class, for_machine, env)
+    env.add_lang_args(comp_class.language, comp_class, for_machine)
     extra_args = extra_args or []
 
     system = env.machines[for_machine].system