linkers: Store a reference to the Environment in the DynamicLinker

For the same reason that the StaticLinker needs this, we need it in the
DynamicLinker as well.

4 files changed, 89 insertions, 77 deletions

diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py
index ff6eb2631..83f7fff4c 100644
--- a/mesonbuild/compilers/detect.py
+++ b/mesonbuild/compilers/detect.py
@@ -386,7 +386,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 _, o, _ = Popen_safe(cmd)
 
             linker = linkers.WASMDynamicLinker(
-                compiler, for_machine, cls.LINKER_PREFIX,
+                compiler, env, for_machine, cls.LINKER_PREFIX,
                 [], version=search_version(o))
             return cls(
                 ccache, compiler, version, for_machine, env,
@@ -419,7 +419,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             version = search_version(arm_ver_str)
             full_version = arm_ver_str
             cls = c.ArmclangCCompiler if lang == 'c' else cpp.ArmclangCPPCompiler
-            linker = linkers.ArmClangDynamicLinker(for_machine, version=version)
+            linker = linkers.ArmClangDynamicLinker(env, for_machine, version=version)
             env.add_lang_args(cls.language, cls, for_machine)
             return cls(
                 ccache, compiler, version, for_machine, env,
@@ -456,7 +456,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 cls = compiler_classes[0] if lang == 'c' else compiler_classes[1]
                 lnk = compiler_classes[2]
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = lnk(compiler, for_machine, version=version)
+                linker = lnk(compiler, env, for_machine, version=version)
                 return cls(
                     ccache, compiler, version, for_machine, env,
                     full_version=full_version, linker=linker)
@@ -493,7 +493,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             target = 'x86' if 'IA-32' in err else 'x86_64'
             cls = c.IntelClCCompiler if lang == 'c' else cpp.IntelClCPPCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
+            linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version)
             return cls(
                 compiler, version, for_machine, env, target,
                 linker=linker)
@@ -502,7 +502,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             target = 'x86' if 'IA-32' in err else 'x86_64'
             cls = c.IntelLLVMClCCompiler if lang == 'c' else cpp.IntelLLVMClCPPCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
+            linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version)
             return cls(
                 compiler, version, for_machine, env, target,
                 linker=linker)
@@ -536,14 +536,14 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
         if 'PGI Compilers' in out:
             cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
+            linker = linkers.PGIDynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version)
             return cls(
                 ccache, compiler, version, for_machine,
                 env, linker=linker)
         if 'NVIDIA Compilers and Tools' in out:
             cls = c.NvidiaHPC_CCompiler if lang == 'c' else cpp.NvidiaHPC_CPPCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
+            linker = linkers.NvidiaHPC_DynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version)
             return cls(
                 ccache, compiler, version, for_machine,
                 env, linker=linker)
@@ -562,14 +562,14 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
         if 'ARM' in out and not ('Metrowerks' in out or 'Freescale' in out):
             cls = c.ArmCCompiler if lang == 'c' else cpp.ArmCPPCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.ArmDynamicLinker(for_machine, version=version)
+            linker = linkers.ArmDynamicLinker(env, for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine,
                 env, full_version=full_version, linker=linker)
         if 'RX Family' in out:
             cls = c.CcrxCCompiler if lang == 'c' else cpp.CcrxCPPCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.CcrxDynamicLinker(for_machine, version=version)
+            linker = linkers.CcrxDynamicLinker(env, for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, env,
                 full_version=full_version, linker=linker)
@@ -588,7 +588,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 cls.gcc_version = _get_gnu_version_from_defines(defines)
 
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = linkers.Xc32DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
+                linker = linkers.Xc32DynamicLinker(compiler, env, for_machine, cls.LINKER_PREFIX, [], version=version)
 
                 return cls(
                     ccache, compiler, version, for_machine,
@@ -597,7 +597,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             else:
                 cls = c.Xc16CCompiler
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = linkers.Xc16DynamicLinker(for_machine, version=version)
+                linker = linkers.Xc16DynamicLinker(env, for_machine, version=version)
 
                 return cls(
                     ccache, compiler, version, for_machine, env,
@@ -606,7 +606,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
         if 'CompCert' in out:
             cls = c.CompCertCCompiler
             env.add_lang_args(cls.language, cls, for_machine)
-            linker = linkers.CompCertDynamicLinker(for_machine, version=version)
+            linker = linkers.CompCertDynamicLinker(env, for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, env,
                 full_version=full_version, linker=linker)
@@ -633,7 +633,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 assert mwld_ver_match is not None, 'for mypy'  # because mypy *should* be complaining that this could be None
                 linker_version = '.'.join(x for x in mwld_ver_match.groups() if x is not None)
 
-                linker = lnk(ld, for_machine, version=linker_version)
+                linker = lnk(ld, env, for_machine, version=linker_version)
             else:
                 raise EnvironmentException(f'Failed to detect linker for {cls.id!r} compiler. Please update your cross file(s).')
 
@@ -653,7 +653,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             if ld is None:
                 raise MesonException(f'{cls.language}_ld was not properly defined in your cross file')
 
-            linker = lnk(ld, for_machine, version=tasking_version)
+            linker = lnk(ld, env, for_machine, version=tasking_version)
             return cls(
                 ccache, compiler, tasking_version, for_machine, env,
                 full_version=full_version, linker=linker)
@@ -708,7 +708,7 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
             val = env.options[key]
             assert isinstance(val, list)
             env.coredata.optstore.set_option(key, cls.to_host_flags_base(val, Phase.LINKER))
-        linker = CudaLinker(compiler, for_machine, CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version())
+        linker = CudaLinker(compiler, env, for_machine, CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version())
         return cls(ccache, compiler, version, for_machine, cpp_compiler, env, linker=linker)
     raise EnvironmentException(f'Could not find suitable CUDA compiler: "{"; ".join([" ".join(c) for c in compilers])}"')
 
@@ -791,7 +791,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 target = 'x86' if 'IA-32' in err else 'x86_64'
                 cls = fortran.IntelLLVMClFortranCompiler
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
+                linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version)
                 return cls(
                     compiler, version, for_machine, env,
                     target, linker=linker)
@@ -801,7 +801,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 target = 'x86' if 'IA-32' in err else 'x86_64'
                 cls = fortran.IntelClFortranCompiler
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = linkers.XilinkDynamicLinker(for_machine, [], version=version)
+                linker = linkers.XilinkDynamicLinker(env, for_machine, [], version=version)
                 return cls(
                     compiler, version, for_machine, env,
                     target, linker=linker)
@@ -828,7 +828,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
             if 'PGI Compilers' in out:
                 cls = fortran.PGIFortranCompiler
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = linkers.PGIDynamicLinker(compiler, for_machine,
+                linker = linkers.PGIDynamicLinker(compiler, env, for_machine,
                                                   cls.LINKER_PREFIX, [], version=version)
                 return cls(
                     compiler, version, for_machine, env,
@@ -837,7 +837,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
             if 'NVIDIA Compilers and Tools' in out:
                 cls = fortran.NvidiaHPC_FortranCompiler
                 env.add_lang_args(cls.language, cls, for_machine)
-                linker = linkers.PGIDynamicLinker(compiler, for_machine,
+                linker = linkers.PGIDynamicLinker(compiler, env, for_machine,
                                                   cls.LINKER_PREFIX, [], version=version)
                 return cls(
                     compiler, version, for_machine, env,
@@ -889,7 +889,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 cls = fortran.NAGFortranCompiler
                 env.add_lang_args(cls.language, cls, for_machine)
                 linker = linkers.NAGDynamicLinker(
-                    compiler, for_machine, cls.LINKER_PREFIX, [],
+                    compiler, env, for_machine, cls.LINKER_PREFIX, [],
                     version=version)
                 return cls(
                     compiler, version, for_machine, env,
@@ -1139,11 +1139,16 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
                 # so we can initialize a new copy for the Rust Compiler
                 # TODO rewrite this without type: ignore
                 assert cc.linker is not None, 'for mypy'
+                linker: DynamicLinker
                 if is_link_exe:
-                    linker = type(cc.linker)(for_machine, always_args, exelist=cc.linker.exelist,   # type: ignore
-                                             version=cc.linker.version, **extra_args)               # type: ignore
+                    # TODO: Due to initializer mismatch we can't use the VisualStudioLikeMixin here
+                    # But all of these ahve the same API so we can just pick one.
+                    linker = T.cast('T.Type[linkers.MSVCDynamicLinker]', type(cc.linker))(
+                        env, for_machine, always_args,
+                        exelist=cc.linker.exelist, version=cc.linker.version,
+                        **extra_args)  # type: ignore
                 else:
-                    linker = type(cc.linker)(compiler, for_machine, cc.LINKER_PREFIX,
+                    linker = type(cc.linker)(compiler, env, for_machine, cc.LINKER_PREFIX,
                                              always_args=always_args, system=cc.linker.system,
                                              version=cc.linker.version, **extra_args)
             elif 'link' in override[0]:
diff --git a/mesonbuild/linkers/detect.py b/mesonbuild/linkers/detect.py
index 5ff19ae3d..d9be37925 100644
--- a/mesonbuild/linkers/detect.py
+++ b/mesonbuild/linkers/detect.py
@@ -73,11 +73,11 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
     if 'LLD' in o.split('\n', maxsplit=1)[0]:
         if 'compatible with GNU linkers' in o:
             return linkers.LLVMDynamicLinker(
-                compiler, for_machine, comp_class.LINKER_PREFIX,
+                compiler, env, for_machine, comp_class.LINKER_PREFIX,
                 override, version=search_version(o))
         elif not invoked_directly:
             return linkers.ClangClDynamicLinker(
-                for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX,
+                env, for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX,
                 version=search_version(o), direct=False, machine=None,
                 rsp_syntax=rsp_syntax)
 
@@ -88,13 +88,13 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
     p, o, e = Popen_safe(compiler + check_args)
     if 'LLD' in o.split('\n', maxsplit=1)[0]:
         return linkers.ClangClDynamicLinker(
-            for_machine, [],
+            env, for_machine, [],
             prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
             exelist=compiler, version=search_version(o), direct=invoked_directly,
             rsp_syntax=rsp_syntax)
     elif 'OPTLINK' in o:
         # Optlink's stdout *may* begin with a \r character.
-        return linkers.OptlinkDynamicLinker(compiler, for_machine, version=search_version(o))
+        return linkers.OptlinkDynamicLinker(compiler, env, for_machine, version=search_version(o))
     elif o.startswith('Microsoft') or e.startswith('Microsoft'):
         out = o or e
         match = re.search(r'.*(X86|X64|ARM|ARM64).*', out)
@@ -104,7 +104,7 @@ def guess_win_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
             target = 'x86'
 
         return linkers.MSVCDynamicLinker(
-            for_machine, [], machine=target, exelist=compiler,
+            env, for_machine, [], machine=target, exelist=compiler,
             prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
             version=search_version(out), direct=invoked_directly,
             rsp_syntax=rsp_syntax)
@@ -170,13 +170,13 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
             lld_cls = linkers.LLVMDynamicLinker
 
         linker = lld_cls(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override, system=system, version=v)
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override, system=system, version=v)
     elif o.startswith("eld"):
         linker = linkers.ELDDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif 'Snapdragon' in e and 'LLVM' in e:
         linker = linkers.QualcommLLVMDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif e.startswith('lld-link: '):
         # The LLD MinGW frontend didn't respond to --version before version 9.0.0,
         # and produced an error message about failing to link (when no object
@@ -194,7 +194,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
             _, o, e = Popen_safe([linker_cmd, '--version'])
             v = search_version(o)
 
-        linker = linkers.LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+        linker = linkers.LLVMDynamicLinker(compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif 'GNU' in o or 'GNU' in e:
         gnu_cls: T.Type[GnuDynamicLinker]
         # this is always the only thing on stdout, except for swift
@@ -205,7 +205,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
             gnu_cls = linkers.MoldDynamicLinker
         else:
             gnu_cls = linkers.GnuBFDDynamicLinker
-        linker = gnu_cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+        linker = gnu_cls(compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     elif 'Solaris' in e or 'Solaris' in o:
         for line in (o+e).split('\n'):
             if 'ld: Software Generation Utilities' in line:
@@ -214,7 +214,7 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
         else:
             v = 'unknown version'
         linker = linkers.SolarisDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override,
             version=v)
     elif 'ld: 0706-012 The -- flag is not recognized' in e:
         if isinstance(comp_class.LINKER_PREFIX, str):
@@ -222,17 +222,17 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
         else:
             _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-V'] + extra_args)
         linker = linkers.AIXDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override,
             version=search_version(e))
     elif o.startswith('zig ld'):
         linker = linkers.ZigCCDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override, version=v)
     # detect xtools first, bug #10805
     elif 'xtools-' in o.split('\n', maxsplit=1)[0]:
         xtools = o.split(' ', maxsplit=1)[0]
         v = xtools.split('-', maxsplit=2)[1]
         linker = linkers.AppleDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override,
             system=system, version=v
         )
     # detect linker on MacOS - must be after other platforms because the
@@ -254,16 +254,16 @@ def guess_nix_linker(env: 'Environment', compiler: T.List[str], comp_class: T.Ty
         else:
             __failed_to_detect_linker(compiler, check_args, o, e)
         linker = linkers.AppleDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override,
             system=system, version=v
         )
     elif 'ld.exe: unrecognized option' in e:
         linker = linkers.OS2AoutDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override,
             version='none')
     elif 'emxomfld: invalid option' in e:
         linker = linkers.OS2OmfDynamicLinker(
-            compiler, for_machine, comp_class.LINKER_PREFIX, override,
+            compiler, env, for_machine, comp_class.LINKER_PREFIX, override,
             version='none')
     else:
         __failed_to_detect_linker(compiler, check_args, o, e)
diff --git a/mesonbuild/linkers/linkers.py b/mesonbuild/linkers/linkers.py
index efb151bea..c53e482da 100644
--- a/mesonbuild/linkers/linkers.py
+++ b/mesonbuild/linkers/linkers.py
@@ -139,11 +139,12 @@ class DynamicLinker(metaclass=abc.ABCMeta):
             ret += self.prefix_arg + [arg]
         return ret
 
-    def __init__(self, exelist: T.List[str],
+    def __init__(self, exelist: T.List[str], env: Environment,
                  for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
                  always_args: T.List[str], *, system: str = 'unknown system',
                  version: str = 'unknown version'):
         self.exelist = exelist
+        self.environment = env
         self.for_machine = for_machine
         self.system = system
         self.version = version
@@ -972,11 +973,11 @@ class LLVMDynamicLinker(GnuLikeDynamicLinkerMixin, PosixDynamicLinkerMixin, Dyna
 
     id = 'ld.lld'
 
-    def __init__(self, exelist: T.List[str],
+    def __init__(self, exelist: T.List[str], env: Environment,
                  for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
                  always_args: T.List[str], *, system: str = 'unknown system',
                  version: str = 'unknown version'):
-        super().__init__(exelist, for_machine, prefix_arg, always_args, system=system, version=version)
+        super().__init__(exelist, env, for_machine, prefix_arg, always_args, system=system, version=version)
 
         # Some targets don't seem to support this argument (windows, wasm, ...)
         self.has_allow_shlib_undefined = self._supports_flag('--allow-shlib-undefined', always_args)
@@ -1062,9 +1063,9 @@ class CcrxDynamicLinker(DynamicLinker):
 
     id = 'rlink'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(['rlink.exe'], for_machine, '', [],
+        super().__init__(['rlink.exe'], env, for_machine, '', [],
                          version=version)
 
     def get_accepts_rsp(self) -> bool:
@@ -1096,9 +1097,9 @@ class Xc16DynamicLinker(DynamicLinker):
 
     id = 'xc16-gcc'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(['xc16-gcc'], for_machine, '', [],
+        super().__init__(['xc16-gcc'], env, for_machine, '', [],
                          version=version)
 
     def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
@@ -1158,9 +1159,9 @@ class CompCertDynamicLinker(DynamicLinker):
 
     id = 'ccomp'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(['ccomp'], for_machine, '', [],
+        super().__init__(['ccomp'], env, for_machine, '', [],
                          version=version)
 
     def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
@@ -1200,9 +1201,9 @@ class TIDynamicLinker(DynamicLinker):
 
     id = 'ti'
 
-    def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+    def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(exelist, for_machine, '', [],
+        super().__init__(exelist, env, for_machine, '', [],
                          version=version)
 
     def get_link_whole_for(self, args: T.List[str]) -> T.List[str]:
@@ -1246,9 +1247,9 @@ class ArmDynamicLinker(PosixDynamicLinkerMixin, DynamicLinker):
 
     id = 'armlink'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(['armlink'], for_machine, '', [],
+        super().__init__(['armlink'], env, for_machine, '', [],
                          version=version)
 
     def get_accepts_rsp(self) -> bool:
@@ -1393,12 +1394,12 @@ class VisualStudioLikeLinkerMixin(DynamicLinkerBase):
         's': ['/INCREMENTAL:NO', '/OPT:REF'],
     }
 
-    def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
-                 prefix_arg: T.Union[str, T.List[str]], always_args: T.List[str], *,
-                 version: str = 'unknown version', direct: bool = True, machine: str = 'x86',
-                 rsp_syntax: RSPFileSyntax = RSPFileSyntax.MSVC):
-        # There's no way I can find to make mypy understand what's going on here
-        super().__init__(exelist, for_machine, prefix_arg, always_args, version=version)
+    def __init__(self, exelist: T.List[str], env: Environment,
+                 for_machine: mesonlib.MachineChoice, prefix_arg: T.Union[str, T.List[str]],
+                 always_args: T.List[str], *, version: str = 'unknown version',
+                 direct: bool = True, machine: str = 'x86', rsp_syntax:
+                 RSPFileSyntax = RSPFileSyntax.MSVC):
+        super().__init__(exelist, env, for_machine, prefix_arg, always_args, version=version)
         self.machine = machine
         self.direct = direct
         self.rsp_syntax = rsp_syntax
@@ -1457,12 +1458,13 @@ class MSVCDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
 
     id = 'link'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
+                 always_args: T.List[str], *,
                  exelist: T.Optional[T.List[str]] = None,
                  prefix: T.Union[str, T.List[str]] = '',
                  machine: str = 'x86', version: str = 'unknown version',
                  direct: bool = True, rsp_syntax: RSPFileSyntax = RSPFileSyntax.MSVC):
-        super().__init__(exelist or ['link.exe'], for_machine,
+        super().__init__(exelist or ['link.exe'], env, for_machine,
                          prefix, always_args, machine=machine, version=version, direct=direct,
                          rsp_syntax=rsp_syntax)
 
@@ -1482,12 +1484,13 @@ class ClangClDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
 
     id = 'lld-link'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
+                 always_args: T.List[str], *,
                  exelist: T.Optional[T.List[str]] = None,
                  prefix: T.Union[str, T.List[str]] = '',
                  machine: str = 'x86', version: str = 'unknown version',
                  direct: bool = True, rsp_syntax: RSPFileSyntax = RSPFileSyntax.MSVC):
-        super().__init__(exelist or ['lld-link.exe'], for_machine,
+        super().__init__(exelist or ['lld-link.exe'], env, for_machine,
                          prefix, always_args, machine=machine, version=version, direct=direct,
                          rsp_syntax=rsp_syntax)
 
@@ -1515,12 +1518,13 @@ class XilinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
 
     id = 'xilink'
 
-    def __init__(self, for_machine: mesonlib.MachineChoice, always_args: T.List[str], *,
+    def __init__(self, env: Environment, for_machine: mesonlib.MachineChoice,
+                 always_args: T.List[str], *,
                  exelist: T.Optional[T.List[str]] = None,
                  prefix: T.Union[str, T.List[str]] = '',
                  machine: str = 'x86', version: str = 'unknown version',
                  direct: bool = True):
-        super().__init__(['xilink.exe'], for_machine, '', always_args, version=version)
+        super().__init__(['xilink.exe'], env, for_machine, '', always_args, version=version)
 
     def get_win_subsystem_args(self, value: str) -> T.List[str]:
         return self._apply_prefix([f'/SUBSYSTEM:{value.upper()}'])
@@ -1667,11 +1671,11 @@ class OptlinkDynamicLinker(VisualStudioLikeLinkerMixin, DynamicLinker):
 
     id = 'optlink'
 
-    def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+    def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
         # Use optlink instead of link so we don't interfere with other link.exe
         # implementations.
-        super().__init__(exelist, for_machine, '', [], version=version)
+        super().__init__(exelist, env, for_machine, '', [], version=version)
 
     def get_allow_undefined_args(self) -> T.List[str]:
         return []
@@ -1738,9 +1742,9 @@ class CudaLinker(PosixDynamicLinkerMixin, DynamicLinker):
 
 class MetrowerksLinker(DynamicLinker):
 
-    def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+    def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(exelist, for_machine, '', [],
+        super().__init__(exelist, env, for_machine, '', [],
                          version=version)
 
     def fatal_warnings(self) -> T.List[str]:
@@ -1789,9 +1793,9 @@ class TaskingLinker(DynamicLinker):
         's': ['-Os'],
     }
 
-    def __init__(self, exelist: T.List[str], for_machine: mesonlib.MachineChoice,
+    def __init__(self, exelist: T.List[str], env: Environment, for_machine: mesonlib.MachineChoice,
                  *, version: str = 'unknown version'):
-        super().__init__(exelist, for_machine, '', [],
+        super().__init__(exelist, env, for_machine, '', [],
                          version=version)
 
     def get_accepts_rsp(self) -> bool:
diff --git a/unittests/internaltests.py b/unittests/internaltests.py
index a1c18efba..8a3e2fd2e 100644
--- a/unittests/internaltests.py
+++ b/unittests/internaltests.py
@@ -214,9 +214,10 @@ class InternalTests(unittest.TestCase):
 
 
     def test_compiler_args_class_visualstudio(self):
-        linker = linkers.MSVCDynamicLinker(MachineChoice.HOST, [])
+        env = get_fake_env()
+        linker = linkers.MSVCDynamicLinker(env, MachineChoice.HOST, [])
         # Version just needs to be > 19.0.0
-        cc = VisualStudioCPPCompiler([], [], '20.00', MachineChoice.HOST, get_fake_env(), 'x64', linker=linker)
+        cc = VisualStudioCPPCompiler([], [], '20.00', MachineChoice.HOST, env, 'x64', linker=linker)
 
         a = cc.compiler_args(cc.get_always_args())
         self.assertEqual(a.to_native(copy=True), ['/nologo', '/showIncludes', '/utf-8', '/Zc:__cplusplus'])
@@ -236,8 +237,9 @@ class InternalTests(unittest.TestCase):
 
     def test_compiler_args_class_gnuld(self):
         ## Test --start/end-group
-        linker = linkers.GnuBFDDynamicLinker([], MachineChoice.HOST, '-Wl,', [])
-        gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, get_fake_env(), linker=linker)
+        env = get_fake_env()
+        linker = linkers.GnuBFDDynamicLinker([], env, MachineChoice.HOST, '-Wl,', [])
+        gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, env, linker=linker)
         ## Ensure that the fake compiler is never called by overriding the relevant function
         gcc.get_default_include_dirs = lambda: ['/usr/include', '/usr/share/include', '/usr/local/include']
         ## Test that 'direct' append and extend works
@@ -264,8 +266,9 @@ class InternalTests(unittest.TestCase):
 
     def test_compiler_args_remove_system(self):
         ## Test --start/end-group
-        linker = linkers.GnuBFDDynamicLinker([], MachineChoice.HOST, '-Wl,', [])
-        gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, get_fake_env(), linker=linker)
+        env = get_fake_env()
+        linker = linkers.GnuBFDDynamicLinker([], env, MachineChoice.HOST, '-Wl,', [])
+        gcc = GnuCCompiler([], [], 'fake', MachineChoice.HOST, env, linker=linker)
         ## Ensure that the fake compiler is never called by overriding the relevant function
         gcc.get_default_include_dirs = lambda: ['/usr/include', '/usr/share/include', '/usr/local/include']
         ## Test that 'direct' append and extend works