compilers: Pass Environment instead of MachineInfo

We end up needing it everywhere, so just store it. This patch is huge
already, so it's just the conversion to passing Environment, more
cleanups to come.

16 files changed, 222 insertions, 273 deletions

diff --git a/mesonbuild/compilers/asm.py b/mesonbuild/compilers/asm.py
index 052e83329..01915bc3e 100644
--- a/mesonbuild/compilers/asm.py
+++ b/mesonbuild/compilers/asm.py
@@ -13,7 +13,6 @@ from .mixins.ti import TICompiler
 if T.TYPE_CHECKING:
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
-    from ..envconfig import MachineInfo
     from ..environment import Environment
 
 nasm_optimization_args: T.Dict[str, T.List[str]] = {
@@ -34,12 +33,13 @@ class ASMCompiler(Compiler):
     _SUPPORTED_ARCHES: T.Set[str] = set()
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
-                 for_machine: MachineChoice, info: MachineInfo,
+                 for_machine: MachineChoice, env: Environment,
                  linker: T.Optional[DynamicLinker] = None,
                  full_version: T.Optional[str] = None, is_cross: bool = False):
+        info = env.machines[for_machine]
         if self._SUPPORTED_ARCHES and info.cpu_family not in self._SUPPORTED_ARCHES:
             raise EnvironmentException(f'ASM Compiler {self.id} does not support building for {info.cpu_family} CPU family.')
-        super().__init__(ccache, exelist, version, for_machine, info, linker, full_version, is_cross)
+        super().__init__(ccache, exelist, version, for_machine, env, linker, full_version, is_cross)
 
     def sanity_check(self, work_dir: str, environment: Environment) -> None:
         return None
@@ -61,10 +61,10 @@ class NasmCompiler(ASMCompiler):
     _SUPPORTED_ARCHES = {'x86', 'x86_64'}
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
-                 for_machine: 'MachineChoice', info: 'MachineInfo',
+                 for_machine: 'MachineChoice', env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None, is_cross: bool = False):
-        super().__init__(ccache, exelist, version, for_machine, info, linker, full_version, is_cross)
+        super().__init__(ccache, exelist, version, for_machine, env, linker, full_version, is_cross)
         if isinstance(self.linker, VisualStudioLikeLinkerMixin):
             self.base_options.add(OptionKey('b_vscrt'))
 
@@ -279,10 +279,10 @@ class TILinearAsmCompiler(TICompiler, ASMCompiler):
     _SUPPORTED_ARCHES = {'c6000'}
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
-                 for_machine: MachineChoice, info: MachineInfo,
+                 for_machine: MachineChoice, env: Environment,
                  linker: T.Optional[DynamicLinker] = None,
                  full_version: T.Optional[str] = None, is_cross: bool = False):
-        ASMCompiler.__init__(self, ccache, exelist, version, for_machine, info, linker, full_version, is_cross)
+        ASMCompiler.__init__(self, ccache, exelist, version, for_machine, env, linker, full_version, is_cross)
         TICompiler.__init__(self)
 
     def needs_static_linker(self) -> bool:
@@ -302,10 +302,10 @@ class MetrowerksAsmCompiler(MetrowerksCompiler, ASMCompiler):
     language = 'nasm'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
-                 for_machine: 'MachineChoice', info: 'MachineInfo',
+                 for_machine: 'MachineChoice', env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None, is_cross: bool = False):
-        ASMCompiler.__init__(self, ccache, exelist, version, for_machine, info, linker, full_version, is_cross)
+        ASMCompiler.__init__(self, ccache, exelist, version, for_machine, env, linker, full_version, is_cross)
         MetrowerksCompiler.__init__(self)
 
         self.warn_args: T.Dict[str, T.List[str]] = {
diff --git a/mesonbuild/compilers/c.py b/mesonbuild/compilers/c.py
index 53ef28e13..4f505852e 100644
--- a/mesonbuild/compilers/c.py
+++ b/mesonbuild/compilers/c.py
@@ -39,7 +39,6 @@ from .compilers import (
 if T.TYPE_CHECKING:
     from ..options import MutableKeyedOptionDictType
     from ..dependencies import Dependency
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -65,11 +64,10 @@ class CCompiler(CLikeCompiler, Compiler):
     language = 'c'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         # If a child ObjC or CPP class has already set it, don't set it ourselves
-        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, env,
                           is_cross=is_cross, full_version=full_version, linker=linker)
         CLikeCompiler.__init__(self)
 
@@ -109,11 +107,10 @@ class CCompiler(CLikeCompiler, Compiler):
 class ClangCCompiler(ClangCStds, ClangCompiler, CCompiler):
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
-        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, linker=linker, full_version=full_version)
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, env, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -180,8 +177,7 @@ class EmscriptenCCompiler(EmscriptenMixin, ClangCCompiler):
     _C23_VERSION = '>=3.1.45'    # 3.1.45 used Clang 18.0.0
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         if not is_cross:
@@ -189,7 +185,7 @@ class EmscriptenCCompiler(EmscriptenMixin, ClangCCompiler):
         if not version_compare(version, '>=1.39.19'):
             raise MesonException('Meson requires Emscripten >= 1.39.19')
         ClangCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                                info, linker=linker,
+                                env, linker=linker,
                                 defines=defines, full_version=full_version)
 
 
@@ -199,11 +195,10 @@ class ArmclangCCompiler(ArmclangCompiler, CCompiler):
     '''
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         ArmclangCompiler.__init__(self)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -237,11 +232,10 @@ class GnuCCompiler(GnuCStds, GnuCompiler, CCompiler):
     _INVALID_PCH_VERSION = ">=3.4.0"
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
-        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, info, linker=linker, full_version=full_version)
+        CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross, env, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = ['-Wall']
         if version_compare(self.version, self._INVALID_PCH_VERSION):
@@ -291,11 +285,10 @@ class GnuCCompiler(GnuCStds, GnuCompiler, CCompiler):
 
 class PGICCompiler(PGICompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
 
@@ -304,11 +297,10 @@ class NvidiaHPC_CCompiler(PGICompiler, CCompiler):
     id = 'nvidia_hpc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -322,12 +314,11 @@ class NvidiaHPC_CCompiler(PGICompiler, CCompiler):
 
 class ElbrusCCompiler(ElbrusCompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         ElbrusCompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -363,11 +354,10 @@ class ElbrusCCompiler(ElbrusCompiler, CCompiler):
 
 class IntelCCompiler(IntelGnuLikeCompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         IntelGnuLikeCompiler.__init__(self)
         self.lang_header = 'c-header'
         default_warn_args = ['-Wall', '-w3']
@@ -430,12 +420,11 @@ class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompi
     _C17_VERSION = '>=19.28'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker,
-                           full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         MSVCCompiler.__init__(self, target)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -465,12 +454,11 @@ class VisualStudioCCompiler(MSVCCompiler, VisualStudioLikeCCompilerMixin, CCompi
 
 class ClangClCCompiler(ClangCStds, ClangClCompiler, VisualStudioLikeCCompilerMixin, CCompiler):
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, [], exelist, version, for_machine, is_cross,
-                           info, linker=linker,
-                           full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         ClangClCompiler.__init__(self, target)
 
     def get_option_std_args(self, target: BuildTarget, env: Environment, subproject: T.Optional[str] = None) -> T.List[str]:
@@ -486,11 +474,11 @@ class IntelClCCompiler(IntelVisualStudioLikeCompiler, VisualStudioLikeCCompilerM
     """Intel "ICL" compiler abstraction."""
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, [], exelist, version, for_machine, is_cross,
-                           info, linker=linker,
+                           env, linker=linker,
                            full_version=full_version)
         IntelVisualStudioLikeCompiler.__init__(self, target)
 
@@ -520,12 +508,11 @@ class IntelLLVMClCCompiler(IntelClCCompiler):
 
 class ArmCCompiler(ArmCompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker,
-                           full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         ArmCompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -547,11 +534,11 @@ class ArmCCompiler(ArmCompiler, CCompiler):
 
 class CcrxCCompiler(CcrxCompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         CcrxCompiler.__init__(self)
 
     # Override CCompiler.get_always_args
@@ -599,11 +586,11 @@ class CcrxCCompiler(CcrxCompiler, CCompiler):
 
 class Xc16CCompiler(Xc16Compiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         Xc16Compiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -649,22 +636,21 @@ class Xc32CCompiler(Xc32CStds, Xc32Compiler, GnuCCompiler):
     """Microchip XC32 C compiler."""
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: MachineInfo,
-                 linker: T.Optional[DynamicLinker] = None,
+                 env: Environment, linker: T.Optional[DynamicLinker] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         GnuCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                              info, linker=linker, full_version=full_version, defines=defines)
+                              env, linker=linker, full_version=full_version, defines=defines)
         Xc32Compiler.__init__(self)
 
 
 class CompCertCCompiler(CompCertCompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         CompCertCompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -691,11 +677,11 @@ class CompCertCCompiler(CompCertCompiler, CCompiler):
 
 class TICCompiler(TICompiler, CCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         TICompiler.__init__(self)
 
     # Override CCompiler.get_always_args
@@ -732,11 +718,11 @@ class MetrowerksCCompilerARM(MetrowerksCompiler, CCompiler):
     id = 'mwccarm'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         MetrowerksCompiler.__init__(self)
 
     def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
@@ -760,11 +746,11 @@ class MetrowerksCCompilerEmbeddedPowerPC(MetrowerksCompiler, CCompiler):
     id = 'mwcceppc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         MetrowerksCompiler.__init__(self)
 
     def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
@@ -787,9 +773,9 @@ class TaskingCCompiler(TaskingCompiler, CCompiler):
     id = 'tasking'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                           info, linker=linker, full_version=full_version)
+                           env, linker=linker, full_version=full_version)
         TaskingCompiler.__init__(self)
diff --git a/mesonbuild/compilers/compilers.py b/mesonbuild/compilers/compilers.py
index 3105adb19..9ae48bfab 100644
--- a/mesonbuild/compilers/compilers.py
+++ b/mesonbuild/compilers/compilers.py
@@ -472,7 +472,7 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta):
     mode = 'COMPILER'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str,
-                 for_machine: MachineChoice, info: 'MachineInfo',
+                 for_machine: MachineChoice, environment: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None, is_cross: bool = False):
         self.exelist = ccache + exelist
@@ -485,10 +485,17 @@ class Compiler(HoldableObject, metaclass=abc.ABCMeta):
         self.for_machine = for_machine
         self.base_options: T.Set[OptionKey] = set()
         self.linker = linker
-        self.info = info
-        self.is_cross = is_cross
+        self.environment = environment
+        self.is_cross = environment.is_cross_build(for_machine)
         self.modes: T.List[Compiler] = []
 
+    @property
+    def info(self) -> MachineInfo:
+        # This must be fetched dynamically because it may be re-evaluated later,
+        # and we could end up with a stale copy
+        # see :class:`Interpreter._redetect_machines()`
+        return self.environment.machines[self.for_machine]
+
     def __repr__(self) -> str:
         repr_str = "<{0}: v{1} `{2}`>"
         return repr_str.format(self.__class__.__name__, self.version,
diff --git a/mesonbuild/compilers/cpp.py b/mesonbuild/compilers/cpp.py
index bfcb924f9..d9facb721 100644
--- a/mesonbuild/compilers/cpp.py
+++ b/mesonbuild/compilers/cpp.py
@@ -37,7 +37,6 @@ from .mixins.microchip import Xc32Compiler, Xc32CPPStds
 if T.TYPE_CHECKING:
     from ..options import MutableKeyedOptionDictType
     from ..dependencies import Dependency
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -68,11 +67,10 @@ class CPPCompiler(CLikeCompiler, Compiler):
     language = 'cpp'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         # If a child ObjCPP class has already set it, don't set it ourselves
-        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, env,
                           is_cross=is_cross, linker=linker,
                           full_version=full_version)
         CLikeCompiler.__init__(self)
@@ -222,12 +220,11 @@ class _StdCPPLibMixin(CompilerMixinBase):
 class ClangCPPCompiler(_StdCPPLibMixin, ClangCPPStds, ClangCompiler, CPPCompiler):
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -357,8 +354,7 @@ class EmscriptenCPPCompiler(EmscriptenMixin, ClangCPPCompiler):
     _CPP26_VERSION = '>=3.1.39'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         if not is_cross:
@@ -366,7 +362,7 @@ class EmscriptenCPPCompiler(EmscriptenMixin, ClangCPPCompiler):
         if not version_compare(version, '>=1.39.19'):
             raise MesonException('Meson requires Emscripten >= 1.39.19')
         ClangCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                                  info, linker=linker,
+                                  env, linker=linker,
                                   defines=defines, full_version=full_version)
 
     def get_option_std_args(self, target: BuildTarget, env: Environment, subproject: T.Optional[str] = None) -> T.List[str]:
@@ -384,11 +380,10 @@ class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler):
     '''
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         ArmclangCompiler.__init__(self)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -432,12 +427,11 @@ class ArmclangCPPCompiler(ArmclangCompiler, CPPCompiler):
 
 class GnuCPPCompiler(_StdCPPLibMixin, GnuCPPStds, GnuCompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -548,11 +542,10 @@ class GnuCPPCompiler(_StdCPPLibMixin, GnuCPPStds, GnuCompiler, CPPCompiler):
 
 class PGICPPCompiler(PGICompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
 
@@ -561,11 +554,10 @@ class NvidiaHPC_CPPCompiler(PGICompiler, CPPCompiler):
     id = 'nvidia_hpc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         PGICompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -582,12 +574,11 @@ class NvidiaHPC_CPPCompiler(PGICompiler, CPPCompiler):
 
 class ElbrusCPPCompiler(ElbrusCompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         ElbrusCompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -665,11 +656,10 @@ class ElbrusCPPCompiler(ElbrusCompiler, CPPCompiler):
 
 class IntelCPPCompiler(IntelGnuLikeCompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         IntelGnuLikeCompiler.__init__(self)
         self.lang_header = 'c++-header'
         default_warn_args = ['-Wall', '-w3', '-Wpch-messages']
@@ -884,11 +874,11 @@ class VisualStudioCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixi
     id = 'msvc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         MSVCCompiler.__init__(self, target)
 
         # By default, MSVC has a broken __cplusplus define that pretends to be c++98:
@@ -929,11 +919,11 @@ class ClangClCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixin, Cl
     id = 'clang-cl'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, [], exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         ClangClCompiler.__init__(self, target)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -944,11 +934,11 @@ class ClangClCPPCompiler(CPP11AsCPP14Mixin, VisualStudioLikeCPPCompilerMixin, Cl
 class IntelClCPPCompiler(VisualStudioLikeCPPCompilerMixin, IntelVisualStudioLikeCompiler, CPPCompiler):
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, [], exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         IntelVisualStudioLikeCompiler.__init__(self, target)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -973,11 +963,10 @@ class IntelLLVMClCPPCompiler(IntelClCPPCompiler):
 
 class ArmCPPCompiler(ArmCompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         ArmCompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -1006,11 +995,10 @@ class ArmCPPCompiler(ArmCompiler, CPPCompiler):
 
 class CcrxCPPCompiler(CcrxCompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         CcrxCompiler.__init__(self)
 
     # Override CCompiler.get_always_args
@@ -1031,11 +1019,10 @@ class CcrxCPPCompiler(CcrxCompiler, CPPCompiler):
 
 class TICPPCompiler(TICompiler, CPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         TICompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -1071,11 +1058,10 @@ class MetrowerksCPPCompilerARM(MetrowerksCompiler, CPPCompiler):
     id = 'mwccarm'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 is_cross: bool, env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         MetrowerksCompiler.__init__(self)
 
     def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
@@ -1099,11 +1085,11 @@ class MetrowerksCPPCompilerEmbeddedPowerPC(MetrowerksCompiler, CPPCompiler):
     id = 'mwcceppc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         CPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                             info, linker=linker, full_version=full_version)
+                             env, linker=linker, full_version=full_version)
         MetrowerksCompiler.__init__(self)
 
     def get_instruction_set_args(self, instruction_set: str) -> T.Optional[T.List[str]]:
@@ -1128,10 +1114,9 @@ class Xc32CPPCompiler(Xc32CPPStds, Xc32Compiler, GnuCPPCompiler):
     """Microchip XC32 C++ compiler."""
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: MachineInfo,
-                 linker: T.Optional[DynamicLinker] = None,
+                 env: Environment, linker: T.Optional[DynamicLinker] = None,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  full_version: T.Optional[str] = None):
         GnuCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                                info, linker=linker, full_version=full_version, defines=defines)
+                                env, linker=linker, full_version=full_version, defines=defines)
         Xc32Compiler.__init__(self)
diff --git a/mesonbuild/compilers/cs.py b/mesonbuild/compilers/cs.py
index 4bbddeb20..37aa0f98b 100644
--- a/mesonbuild/compilers/cs.py
+++ b/mesonbuild/compilers/cs.py
@@ -15,7 +15,6 @@ from .mixins.islinker import BasicLinkerIsCompilerMixin
 
 if T.TYPE_CHECKING:
     from ..dependencies import Dependency
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..mesonlib import MachineChoice
 
@@ -35,8 +34,8 @@ class CsCompiler(BasicLinkerIsCompilerMixin, Compiler):
     language = 'cs'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', runner: T.Optional[str] = None):
-        super().__init__([], exelist, version, for_machine, info)
+                 env: Environment, runner: T.Optional[str] = None):
+        super().__init__([], exelist, version, for_machine, env)
         self.runner = runner
 
     @classmethod
@@ -119,8 +118,8 @@ class MonoCompiler(CsCompiler):
     id = 'mono'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo'):
-        super().__init__(exelist, version, for_machine, info, runner='mono')
+                 env: Environment):
+        super().__init__(exelist, version, for_machine, env, runner='mono')
 
     def rsp_file_syntax(self) -> 'RSPFileSyntax':
         return RSPFileSyntax.GCC
diff --git a/mesonbuild/compilers/cuda.py b/mesonbuild/compilers/cuda.py
index bf80a42ad..be92dfbc8 100644
--- a/mesonbuild/compilers/cuda.py
+++ b/mesonbuild/compilers/cuda.py
@@ -22,7 +22,6 @@ if T.TYPE_CHECKING:
     from ..options import MutableKeyedOptionDictType
     from ..dependencies import Dependency
     from ..environment import Environment  # noqa: F401
-    from ..envconfig import MachineInfo
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
 
@@ -183,11 +182,10 @@ class CudaCompiler(Compiler):
     id = 'nvcc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool,
-                 host_compiler: Compiler, info: 'MachineInfo',
+                 is_cross: bool, host_compiler: Compiler, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
-        super().__init__(ccache, exelist, version, for_machine, info, linker=linker, full_version=full_version, is_cross=is_cross)
+        super().__init__(ccache, exelist, version, for_machine, env, linker=linker, full_version=full_version, is_cross=is_cross)
         self.host_compiler = host_compiler
         self.base_options = host_compiler.base_options
         # -Wpedantic generates useless churn due to nvcc's dual compilation model producing
diff --git a/mesonbuild/compilers/d.py b/mesonbuild/compilers/d.py
index 9f662add3..c37bb679a 100644
--- a/mesonbuild/compilers/d.py
+++ b/mesonbuild/compilers/d.py
@@ -430,11 +430,11 @@ class DCompiler(Compiler):
     language = 'd'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', arch: str, *,
+                 env: Environment, arch: str, *,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None,
                  is_cross: bool = False):
-        super().__init__([], exelist, version, for_machine, info, linker=linker,
+        super().__init__([], exelist, version, for_machine, env, linker=linker,
                          full_version=full_version, is_cross=is_cross)
         self.arch = arch
 
@@ -639,11 +639,11 @@ class GnuDCompiler(GnuCompiler, DCompiler):
     id = 'gcc'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', arch: str, *,
+                 env: Environment, arch: str, *,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None,
                  is_cross: bool = False):
-        DCompiler.__init__(self, exelist, version, for_machine, info, arch,
+        DCompiler.__init__(self, exelist, version, for_machine, env, arch,
                            linker=linker,
                            full_version=full_version, is_cross=is_cross)
         GnuCompiler.__init__(self, {})
@@ -722,11 +722,11 @@ class LLVMDCompiler(DmdLikeCompilerMixin, DCompiler):
     id = 'llvm'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', arch: str, *,
+                 env: Environment, arch: str, *,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None,
                  is_cross: bool = False, version_output: T.Optional[str] = None):
-        DCompiler.__init__(self, exelist, version, for_machine, info, arch,
+        DCompiler.__init__(self, exelist, version, for_machine, env, arch,
                            linker=linker,
                            full_version=full_version, is_cross=is_cross)
         DmdLikeCompilerMixin.__init__(self, dmd_frontend_version=find_ldc_dmd_frontend_version(version_output))
@@ -785,11 +785,11 @@ class DmdDCompiler(DmdLikeCompilerMixin, DCompiler):
     id = 'dmd'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', arch: str, *,
+                 env: Environment, arch: str, *,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None,
                  is_cross: bool = False):
-        DCompiler.__init__(self, exelist, version, for_machine, info, arch,
+        DCompiler.__init__(self, exelist, version, for_machine, env, arch,
                            linker=linker,
                            full_version=full_version, is_cross=is_cross)
         DmdLikeCompilerMixin.__init__(self, version)
diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py
index bf72d347c..f1910df70 100644
--- a/mesonbuild/compilers/detect.py
+++ b/mesonbuild/compilers/detect.py
@@ -285,7 +285,6 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
     if override_compiler is not None:
         compilers = [override_compiler]
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
     cls: T.Union[T.Type[CCompiler], T.Type[CPPCompiler]]
     lnk: T.Union[T.Type[StaticLinker], T.Type[DynamicLinker]]
 
@@ -373,7 +372,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
 
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
-                info, defines=defines, full_version=full_version,
+                env, defines=defines, full_version=full_version,
                 linker=linker)
 
         if 'Emscripten' in out:
@@ -391,7 +390,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 compiler, for_machine, cls.LINKER_PREFIX,
                 [], version=search_version(o))
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 linker=linker, full_version=full_version)
 
         if 'Arm C/C++/Fortran Compiler' in out:
@@ -404,7 +403,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 cls = cpp.ArmLtdClangCPPCompiler
             linker = guess_nix_linker(env, compiler, cls, version, for_machine)
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 linker=linker)
         if 'armclang' in out:
             # The compiler version is not present in the first line of output,
@@ -424,7 +423,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             linker = linkers.ArmClangDynamicLinker(for_machine, version=version)
             env.add_lang_args(cls.language, cls, for_machine)
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 full_version=full_version, linker=linker)
         if 'CL.EXE COMPATIBILITY' in out:
             # if this is clang-cl masquerading as cl, detect it as cl, not
@@ -443,7 +442,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             cls = c.ClangClCCompiler if lang == 'c' else cpp.ClangClCPPCompiler
             linker = guess_win_linker(env, ['lld-link'], cls, version, for_machine)
             return cls(
-                compiler, version, for_machine, is_cross, info, target,
+                compiler, version, for_machine, is_cross, env, target,
                 linker=linker)
 
         # must be detected here before clang because TI compilers contain 'clang' in their output and so that they can be detected as 'clang'
@@ -460,7 +459,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 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,
+                    ccache, compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
         if 'clang' in out or 'Clang' in out:
@@ -487,7 +486,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 linker = guess_nix_linker(env, compiler, cls, version, for_machine)
 
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 defines=defines, full_version=full_version, linker=linker)
 
         if 'Intel(R) C++ Intel(R)' in err:
@@ -497,7 +496,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             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,
+                compiler, version, for_machine, is_cross, env, target,
                 linker=linker)
         if 'Intel(R) oneAPI DPC++/C++ Compiler for applications' in err:
             version = search_version(err)
@@ -506,7 +505,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             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,
+                compiler, version, for_machine, is_cross, env, target,
                 linker=linker)
         if 'Microsoft' in out or 'Microsoft' in err:
             # Latest versions of Visual Studio print version
@@ -533,7 +532,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                     mlog.warning('Visual Studio support requires ccache 4.6 or higher. You have ccache {}. '.format(ccache_exe.get_version()), once=True)
                     ccache = []
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info, target,
+                ccache, compiler, version, for_machine, is_cross, env, target,
                 full_version=cl_signature, linker=linker)
         if 'PGI Compilers' in out:
             cls = c.PGICCompiler if lang == 'c' else cpp.PGICPPCompiler
@@ -541,25 +540,25 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             linker = linkers.PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
-                info, linker=linker)
+                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)
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
-                info, linker=linker)
+                env, linker=linker)
         if '(ICC)' in out:
             cls = c.IntelCCompiler if lang == 'c' else cpp.IntelCPPCompiler
             l = guess_nix_linker(env, compiler, cls, version, for_machine)
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 full_version=full_version, linker=l)
         if 'Intel(R) oneAPI' in out:
             cls = c.IntelLLVMCCompiler if lang == 'c' else cpp.IntelLLVMCPPCompiler
             l = guess_nix_linker(env, compiler, cls, version, for_machine)
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 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
@@ -567,13 +566,13 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             linker = linkers.ArmDynamicLinker(for_machine, version=version)
             return cls(
                 ccache, compiler, version, for_machine, is_cross,
-                info, full_version=full_version, linker=linker)
+                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)
             return cls(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 full_version=full_version, linker=linker)
 
         if 'Microchip' in out:
@@ -594,7 +593,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
 
                 return cls(
                     ccache, compiler, version, for_machine, is_cross,
-                    info, defines=defines, full_version=full_version,
+                    env, defines=defines, full_version=full_version,
                     linker=linker)
             else:
                 cls = c.Xc16CCompiler
@@ -602,7 +601,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 linker = linkers.Xc16DynamicLinker(for_machine, version=version)
 
                 return cls(
-                    ccache, compiler, version, for_machine, is_cross, info,
+                    ccache, compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
         if 'CompCert' in out:
@@ -610,7 +609,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
             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,
+                ccache, compiler, version, for_machine, is_cross, env,
                 full_version=full_version, linker=linker)
 
         if 'Metrowerks C/C++' in out or 'Freescale C/C++' in out:
@@ -640,7 +639,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
                 raise EnvironmentException(f'Failed to detect linker for {cls.id!r} compiler. Please update your cross file(s).')
 
             return cls(
-                ccache, compiler, compiler_version, for_machine, is_cross, info,
+                ccache, compiler, compiler_version, for_machine, is_cross, env,
                 full_version=full_version, linker=linker)
         if 'TASKING VX-toolset' in err:
             cls = c.TaskingCCompiler
@@ -657,7 +656,7 @@ def _detect_c_or_cpp_compiler(env: 'Environment', lang: str, for_machine: Machin
 
             linker = lnk(ld, for_machine, version=tasking_version)
             return cls(
-                ccache, compiler, tasking_version, for_machine, is_cross, info,
+                ccache, compiler, tasking_version, for_machine, is_cross, env,
                 full_version=full_version, linker=linker)
 
     _handle_exceptions(popen_exceptions, compilers)
@@ -677,7 +676,6 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
     is_cross = env.is_cross_build(for_machine)
     compilers, ccache_exe = _get_compilers(env, 'cuda', for_machine)
     ccache = ccache_exe.get_command() if (ccache_exe and ccache_exe.found()) else []
-    info = env.machines[for_machine]
     for compiler in compilers:
         arg = '--version'
         try:
@@ -713,7 +711,7 @@ def detect_cuda_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
             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())
-        return cls(ccache, compiler, version, for_machine, is_cross, host_compiler=cpp_compiler, info=info, linker=linker)
+        return cls(ccache, compiler, version, for_machine, is_cross, cpp_compiler, env, linker=linker)
     raise EnvironmentException(f'Could not find suitable CUDA compiler: "{"; ".join([" ".join(c) for c in compilers])}"')
 
 def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
@@ -722,7 +720,6 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
     popen_exceptions: T.Dict[str, T.Union[Exception, str]] = {}
     compilers, ccache = _get_compilers(env, 'fortran', for_machine)
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
     cls: T.Type[FortranCompiler]
     for compiler in compilers:
         # capture help text for possible fallback
@@ -758,14 +755,14 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                     cls = fortran.ElbrusFortranCompiler
                     linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                     return cls(
-                        compiler, version, for_machine, is_cross, info,
+                        compiler, version, for_machine, is_cross, env,
                         defines, full_version=full_version, linker=linker)
                 else:
                     version = _get_gnu_version_from_defines(defines)
                     cls = fortran.GnuFortranCompiler
                     linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                     return cls(
-                        compiler, version, for_machine, is_cross, info,
+                        compiler, version, for_machine, is_cross, env,
                         defines, full_version=full_version, linker=linker)
 
             if 'Arm C/C++/Fortran Compiler' in out:
@@ -775,13 +772,13 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 version = '.'.join([x for x in arm_ver_match.groups() if x is not None])
                 linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     linker=linker)
             if 'G95' in out:
                 cls = fortran.G95FortranCompiler
                 linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'Sun Fortran' in err:
@@ -789,7 +786,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 cls = fortran.SunFortranCompiler
                 linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'Intel(R) Fortran Compiler for applications' in err:
@@ -799,7 +796,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 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,
+                    compiler, version, for_machine, is_cross, env,
                     target, linker=linker)
 
             if 'Intel(R) Visual Fortran' in err or 'Intel(R) Fortran' in err:
@@ -809,26 +806,26 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 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,
+                    compiler, version, for_machine, is_cross, env,
                     target, linker=linker)
 
             if 'ifort (IFORT)' in out:
                 cls = fortran.IntelFortranCompiler
                 linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'ifx (IFORT)' in out or 'ifx (IFX)' in out:
                 cls = fortran.IntelLLVMFortranCompiler
                 linker = guess_nix_linker(env, compiler, cls, version, for_machine)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'PathScale EKOPath(tm)' in err:
                 return fortran.PathScaleFortranCompiler(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version)
 
             if 'PGI Compilers' in out:
@@ -837,7 +834,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 linker = linkers.PGIDynamicLinker(compiler, for_machine,
                                                   cls.LINKER_PREFIX, [], version=version)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'NVIDIA Compilers and Tools' in out:
@@ -846,7 +843,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 linker = linkers.PGIDynamicLinker(compiler, for_machine,
                                                   cls.LINKER_PREFIX, [], version=version)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             def _get_linker_try_windows(cls: T.Type['Compiler']) -> T.Optional['DynamicLinker']:
@@ -871,14 +868,14 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 cls = fortran.LlvmFlangFortranCompiler
                 linker = _get_linker_try_windows(cls)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'flang' in out or 'clang' in out:
                 cls = fortran.ClassicFlangFortranCompiler
                 linker = _get_linker_try_windows(cls)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'Open64 Compiler Suite' in err:
@@ -886,7 +883,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                 linker = guess_nix_linker(env,
                                           compiler, cls, version, for_machine)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
             if 'NAG Fortran' in err:
@@ -898,7 +895,7 @@ def detect_fortran_compiler(env: 'Environment', for_machine: MachineChoice) -> C
                     compiler, for_machine, cls.LINKER_PREFIX, [],
                     version=version)
                 return cls(
-                    compiler, version, for_machine, is_cross, info,
+                    compiler, version, for_machine, is_cross, env,
                     full_version=full_version, linker=linker)
 
     _handle_exceptions(popen_exceptions, compilers)
@@ -916,7 +913,6 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine:
     compilers, ccache_exe = _get_compilers(env, lang, for_machine)
     ccache = ccache_exe.get_command() if (ccache_exe and ccache_exe.found()) else []
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
     comp: T.Union[T.Type[objc.ObjCCompiler], T.Type[objcpp.ObjCPPCompiler]]
 
     for compiler in compilers:
@@ -936,7 +932,7 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine:
             comp = objc.GnuObjCCompiler if lang == 'objc' else objcpp.GnuObjCPPCompiler
             linker = guess_nix_linker(env, compiler, comp, version, for_machine)
             c = comp(
-                ccache, compiler, version, for_machine, is_cross, info,
+                ccache, compiler, version, for_machine, is_cross, env,
                 defines, linker=linker)
             if not c.compiles('int main(void) { return 0; }', env)[0]:
                 popen_exceptions[join_args(compiler)] = f'GCC was not built with support for {"objective-c" if lang == "objc" else "objective-c++"}'
@@ -963,14 +959,13 @@ def _detect_objc_or_objcpp_compiler(env: 'Environment', lang: str, for_machine:
                 linker = guess_nix_linker(env, compiler, comp, version, for_machine)
             return comp(
                 ccache, compiler, version, for_machine,
-                is_cross, info, linker=linker, defines=defines)
+                is_cross, env, linker=linker, defines=defines)
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
 def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
     from .java import JavaCompiler
     exelist = env.lookup_binary_entry(for_machine, 'java')
-    info = env.machines[for_machine]
     if exelist is None:
         # TODO support fallback
         exelist = [defaults['java'][0]]
@@ -987,14 +982,13 @@ def detect_java_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
                 version = parts[1]
         comp_class = JavaCompiler
         env.add_lang_args(comp_class.language, comp_class, for_machine)
-        return comp_class(exelist, version, for_machine, info)
+        return comp_class(exelist, version, for_machine, env)
     raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
 def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
     from . import cs
     compilers, ccache = _get_compilers(env, 'cs', for_machine)
     popen_exceptions = {}
-    info = env.machines[for_machine]
     for comp in compilers:
         try:
             p, out, err = Popen_safe_logged(comp + ['--version'], msg='Detecting compiler via')
@@ -1011,7 +1005,7 @@ def detect_cs_compiler(env: 'Environment', for_machine: MachineChoice) -> Compil
         else:
             continue
         env.add_lang_args(cls.language, cls, for_machine)
-        return cls(comp, version, for_machine, info)
+        return cls(comp, version, for_machine, env)
 
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
@@ -1021,7 +1015,6 @@ def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Co
     from .cython import CythonCompiler
     compilers, _ = _get_compilers(env, 'cython', MachineChoice.BUILD)
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
 
     popen_exceptions: T.Dict[str, Exception] = {}
     for comp in compilers:
@@ -1041,7 +1034,7 @@ def detect_cython_compiler(env: 'Environment', for_machine: MachineChoice) -> Co
         if version is not None:
             comp_class = CythonCompiler
             env.add_lang_args(comp_class.language, comp_class, for_machine)
-            return comp_class([], comp, version, for_machine, info, is_cross=is_cross)
+            return comp_class([], comp, version, for_machine, env, is_cross=is_cross)
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
 
@@ -1049,7 +1042,6 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
     from .vala import ValaCompiler
     exelist = env.lookup_binary_entry(MachineChoice.BUILD, 'vala')
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
     if exelist is None:
         # TODO support fallback
         exelist = [defaults['vala'][0]]
@@ -1062,7 +1054,7 @@ def detect_vala_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
     if 'Vala' in out:
         comp_class = ValaCompiler
         env.add_lang_args(comp_class.language, comp_class, for_machine)
-        return comp_class(exelist, version, for_machine, is_cross, info)
+        return comp_class(exelist, version, for_machine, is_cross, env)
     raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
 def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> RustCompiler:
@@ -1071,7 +1063,6 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
     popen_exceptions: T.Dict[str, Exception] = {}
     compilers, _ = _get_compilers(env, 'rust', for_machine)
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
 
     cc = detect_c_compiler(env, for_machine)
     is_link_exe = isinstance(cc.linker, linkers.VisualStudioLikeLinkerMixin)
@@ -1185,7 +1176,7 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
 
             env.add_lang_args(cls.language, cls, for_machine)
             return cls(
-                compiler, version, for_machine, is_cross, info,
+                compiler, version, for_machine, is_cross, env,
                 linker=linker, full_version=full_version)
 
     _handle_exceptions(popen_exceptions, compilers)
@@ -1193,7 +1184,6 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
 
 def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compiler:
     from . import c, d
-    info = env.machines[for_machine]
 
     # Detect the target architecture, required for proper architecture handling on Windows.
     # MSVC compiler is required for correct platform detection.
@@ -1208,6 +1198,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile
 
     popen_exceptions = {}
     is_cross = env.is_cross_build(for_machine)
+    info = env.machines[for_machine]
     compilers, ccache = _get_compilers(env, 'd', for_machine)
     cls: T.Type[d.DCompiler]
     for exelist in compilers:
@@ -1264,14 +1255,14 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile
                 windows_proof_rm(objfile)
 
             return cls(
-                exelist, version, for_machine, info, arch,
+                exelist, version, for_machine, env, arch,
                 full_version=full_version, linker=linker,
                 is_cross=is_cross, version_output=out)
         elif 'gdc' in out:
             cls = d.GnuDCompiler
             linker = guess_nix_linker(env, exelist, cls, version, for_machine)
             return cls(
-                exelist, version, for_machine, info, arch,
+                exelist, version, for_machine, env, arch,
                 is_cross=is_cross, full_version=full_version, linker=linker)
         elif 'The D Language Foundation' in out or 'Digital Mars' in out:
             cls = d.DmdDCompiler
@@ -1301,7 +1292,7 @@ def detect_d_compiler(env: 'Environment', for_machine: MachineChoice) -> Compile
                 windows_proof_rm(objfile)
 
             return cls(
-                exelist, version, for_machine, info, arch,
+                exelist, version, for_machine, env, arch,
                 full_version=full_version, linker=linker)
         raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
@@ -1312,7 +1303,6 @@ def detect_swift_compiler(env: 'Environment', for_machine: MachineChoice) -> Com
     from .swift import SwiftCompiler
     exelist = env.lookup_binary_entry(for_machine, 'swift')
     is_cross = env.is_cross_build(for_machine)
-    info = env.machines[for_machine]
     if exelist is None:
         # TODO support fallback
         exelist = [defaults['swift'][0]]
@@ -1330,7 +1320,7 @@ def detect_swift_compiler(env: 'Environment', for_machine: MachineChoice) -> Com
                                       exelist, cls, version, for_machine,
                                       extra_args=[f.name, '-o', '/dev/null'])
         return cls(
-            exelist, version, for_machine, is_cross, info, linker=linker)
+            exelist, version, for_machine, is_cross, env, linker=linker)
 
     raise EnvironmentException('Unknown compiler: ' + join_args(exelist))
 
@@ -1344,10 +1334,6 @@ def detect_nasm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
 
     # We need a C compiler to properly detect the machine info and linker
     cc = detect_c_compiler(env, for_machine)
-    if not is_cross:
-        info = detect_machine_info({'c': cc})
-    else:
-        info = env.machines[for_machine]
 
     popen_exceptions: T.Dict[str, Exception] = {}
     for comp in compilers:
@@ -1366,20 +1352,20 @@ def detect_nasm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
         if 'NASM' in output:
             comp_class = NasmCompiler
             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)
+            return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross)
         elif 'yasm' in output:
             comp_class = YasmCompiler
             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)
+            return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross)
         elif 'Metrowerks' in output or 'Freescale' in output:
             if 'ARM' in output:
                 comp_class_mwasmarm = MetrowerksAsmCompilerARM
                 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)
+                return comp_class_mwasmarm([], comp, version, for_machine, env, cc.linker, is_cross=is_cross)
             else:
                 comp_class_mwasmeppc = MetrowerksAsmCompilerEmbeddedPowerPC
                 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)
+                return comp_class_mwasmeppc([], comp, version, for_machine, env, cc.linker, is_cross=is_cross)
 
     _handle_exceptions(popen_exceptions, compilers)
     raise EnvironmentException('Unreachable code (exception to make mypy happy)')
@@ -1419,7 +1405,7 @@ def detect_masm_compiler(env: 'Environment', for_machine: MachineChoice) -> Comp
         output = Popen_safe(comp + [arg])[2]
         version = search_version(output)
         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)
+        return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross)
     except OSError as e:
         popen_exceptions[' '.join(comp + [arg])] = e
     _handle_exceptions(popen_exceptions, [comp])
@@ -1430,7 +1416,6 @@ def detect_linearasm_compiler(env: Environment, for_machine: MachineChoice) -> C
     comp = ['cl6x']
     comp_class: T.Type[ASMCompiler] = TILinearAsmCompiler
     arg = '-h'
-    info = env.machines[for_machine]
     cc = detect_c_compiler(env, for_machine)
     is_cross = env.is_cross_build(for_machine)
 
@@ -1439,7 +1424,7 @@ def detect_linearasm_compiler(env: Environment, for_machine: MachineChoice) -> C
         output = Popen_safe(comp + [arg])[2]
         version = search_version(output)
         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)
+        return comp_class([], comp, version, for_machine, env, cc.linker, is_cross=is_cross)
     except OSError as e:
         popen_exceptions[' '.join(comp + [arg])] = e
     _handle_exceptions(popen_exceptions, [comp])
diff --git a/mesonbuild/compilers/fortran.py b/mesonbuild/compilers/fortran.py
index 6f4f3d2c1..447094ce9 100644
--- a/mesonbuild/compilers/fortran.py
+++ b/mesonbuild/compilers/fortran.py
@@ -29,7 +29,6 @@ from mesonbuild.mesonlib import (
 if T.TYPE_CHECKING:
     from ..options import MutableKeyedOptionDictType
     from ..dependencies import Dependency
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -41,10 +40,9 @@ class FortranCompiler(CLikeCompiler, Compiler):
     language = 'fortran'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
-        Compiler.__init__(self, [], exelist, version, for_machine, info,
+        Compiler.__init__(self, [], exelist, version, for_machine, env,
                           is_cross=is_cross, full_version=full_version, linker=linker)
         CLikeCompiler.__init__(self)
 
@@ -260,12 +258,12 @@ class FortranCompiler(CLikeCompiler, Compiler):
 class GnuFortranCompiler(GnuCompiler, FortranCompiler):
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
+                 env: Environment,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = ['-Wall']
@@ -328,12 +326,12 @@ class GnuFortranCompiler(GnuCompiler, FortranCompiler):
 
 class ElbrusFortranCompiler(ElbrusCompiler, FortranCompiler):
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
+                 env: Environment,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine, is_cross,
-                                 info, linker=linker, full_version=full_version)
+                                 env, linker=linker, full_version=full_version)
         ElbrusCompiler.__init__(self)
 
     def get_options(self) -> 'MutableKeyedOptionDictType':
@@ -351,11 +349,10 @@ class G95FortranCompiler(FortranCompiler):
     id = 'g95'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         default_warn_args = ['-Wall']
         self.warn_args = {'0': [],
@@ -397,11 +394,10 @@ class IntelFortranCompiler(IntelGnuLikeCompiler, FortranCompiler):
     id = 'intel'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         # FIXME: Add support for OS X and Windows in detect_fortran_compiler so
         # we are sent the type of compiler
@@ -457,11 +453,11 @@ class IntelClFortranCompiler(IntelVisualStudioLikeCompiler, FortranCompiler):
     always_args = ['/nologo']
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', target: str,
+                 is_cross: bool, env: Environment, target: str,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         IntelVisualStudioLikeCompiler.__init__(self, target)
         self.file_suffixes = ('f90', 'f', 'for', 'ftn', 'fpp', )
@@ -503,11 +499,10 @@ class PathScaleFortranCompiler(FortranCompiler):
     id = 'pathscale'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         default_warn_args = ['-fullwarn']
         self.warn_args = {'0': [],
@@ -523,11 +518,10 @@ class PathScaleFortranCompiler(FortranCompiler):
 class PGIFortranCompiler(PGICompiler, FortranCompiler):
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         PGICompiler.__init__(self)
 
@@ -549,11 +543,10 @@ class NvidiaHPC_FortranCompiler(PGICompiler, FortranCompiler):
     id = 'nvidia_hpc'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         PGICompiler.__init__(self)
 
@@ -570,11 +563,10 @@ class ClassicFlangFortranCompiler(ClangCompiler, FortranCompiler):
     id = 'flang'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         ClangCompiler.__init__(self, {})
         default_warn_args = ['-Minform=inform']
@@ -606,10 +598,10 @@ class LlvmFlangFortranCompiler(ClangCompiler, FortranCompiler):
     id = 'llvm-flang'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo', linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         ClangCompiler.__init__(self, {})
         default_warn_args = ['-Wall']
@@ -660,11 +652,10 @@ class Open64FortranCompiler(FortranCompiler):
     id = 'open64'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         default_warn_args = ['-fullwarn']
         self.warn_args = {'0': [],
@@ -682,11 +673,10 @@ class NAGFortranCompiler(FortranCompiler):
     id = 'nagfor'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice, is_cross: bool,
-                 info: 'MachineInfo',
-                 linker: T.Optional['DynamicLinker'] = None,
+                 env: Environment, linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         FortranCompiler.__init__(self, exelist, version, for_machine,
-                                 is_cross, info, linker=linker,
+                                 is_cross, env, linker=linker,
                                  full_version=full_version)
         # Warnings are on by default; -w disables (by category):
         self.warn_args = {
diff --git a/mesonbuild/compilers/java.py b/mesonbuild/compilers/java.py
index 47d2ac9cd..7db9af86a 100644
--- a/mesonbuild/compilers/java.py
+++ b/mesonbuild/compilers/java.py
@@ -15,7 +15,6 @@ from .compilers import Compiler
 from .mixins.islinker import BasicLinkerIsCompilerMixin
 
 if T.TYPE_CHECKING:
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..mesonlib import MachineChoice
 
@@ -38,8 +37,8 @@ class JavaCompiler(BasicLinkerIsCompilerMixin, Compiler):
     }
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 info: 'MachineInfo', full_version: T.Optional[str] = None):
-        super().__init__([], exelist, version, for_machine, info, full_version=full_version)
+                 env: Environment, full_version: T.Optional[str] = None):
+        super().__init__([], exelist, version, for_machine, env, full_version=full_version)
         self.javarunner = 'java'
 
     def get_warn_args(self, level: str) -> T.List[str]:
diff --git a/mesonbuild/compilers/mixins/apple.py b/mesonbuild/compilers/mixins/apple.py
index ca655384d..a66c682a9 100644
--- a/mesonbuild/compilers/mixins/apple.py
+++ b/mesonbuild/compilers/mixins/apple.py
@@ -11,6 +11,7 @@ from ...mesonlib import MesonException
 if T.TYPE_CHECKING:
     from ..._typing import ImmutableListProtocol
     from ...environment import Environment
+    from ...envconfig import MachineInfo
     from ..compilers import Compiler
 else:
     # This is a bit clever, for mypy we pretend that these mixins descend from
@@ -26,6 +27,10 @@ class AppleCompilerMixin(Compiler):
 
     __BASE_OMP_FLAGS: ImmutableListProtocol[str] = ['-Xpreprocessor', '-fopenmp']
 
+    if T.TYPE_CHECKING:
+        # Older versions of mypy can't figure this out
+        info: MachineInfo
+
     def openmp_flags(self, env: Environment) -> T.List[str]:
         """Flags required to compile with OpenMP on Apple.
 
diff --git a/mesonbuild/compilers/objc.py b/mesonbuild/compilers/objc.py
index d013417fc..8cbe2933d 100644
--- a/mesonbuild/compilers/objc.py
+++ b/mesonbuild/compilers/objc.py
@@ -15,7 +15,6 @@ from .mixins.clike import CLikeCompiler
 from .mixins.gnu import GnuCompiler, GnuCStds, gnu_common_warning_args, gnu_objc_warning_args
 
 if T.TYPE_CHECKING:
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -28,10 +27,10 @@ class ObjCCompiler(CLikeCompiler, Compiler):
     language = 'objc'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
-        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, env,
                           is_cross=is_cross, full_version=full_version,
                           linker=linker)
         CLikeCompiler.__init__(self)
@@ -60,12 +59,12 @@ class ObjCCompiler(CLikeCompiler, Compiler):
 
 class GnuObjCCompiler(GnuCStds, GnuCompiler, ObjCCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                              info, linker=linker, full_version=full_version)
+                              env, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -90,12 +89,12 @@ class GnuObjCCompiler(GnuCStds, GnuCompiler, ObjCCompiler):
 
 class ClangObjCCompiler(ClangCStds, ClangCompiler, ObjCCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         ObjCCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                              info, linker=linker, full_version=full_version)
+                              env, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
diff --git a/mesonbuild/compilers/objcpp.py b/mesonbuild/compilers/objcpp.py
index 441428b2f..d205dd1fc 100644
--- a/mesonbuild/compilers/objcpp.py
+++ b/mesonbuild/compilers/objcpp.py
@@ -15,7 +15,6 @@ from .mixins.clang import ClangCompiler, ClangCPPStds
 from .mixins.clike import CLikeCompiler
 
 if T.TYPE_CHECKING:
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -28,10 +27,10 @@ class ObjCPPCompiler(CLikeCompiler, Compiler):
     language = 'objcpp'
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
-        Compiler.__init__(self, ccache, exelist, version, for_machine, info,
+        Compiler.__init__(self, ccache, exelist, version, for_machine, env,
                           is_cross=is_cross, full_version=full_version,
                           linker=linker)
         CLikeCompiler.__init__(self)
@@ -65,12 +64,12 @@ class ObjCPPCompiler(CLikeCompiler, Compiler):
 
 class GnuObjCPPCompiler(GnuCPPStds, GnuCompiler, ObjCPPCompiler):
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                                info, linker=linker, full_version=full_version)
+                                env, linker=linker, full_version=full_version)
         GnuCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
@@ -96,12 +95,12 @@ class GnuObjCPPCompiler(GnuCPPStds, GnuCompiler, ObjCPPCompiler):
 class ClangObjCPPCompiler(ClangCPPStds, ClangCompiler, ObjCPPCompiler):
 
     def __init__(self, ccache: T.List[str], exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  defines: T.Optional[T.Dict[str, str]] = None,
                  linker: T.Optional['DynamicLinker'] = None,
                  full_version: T.Optional[str] = None):
         ObjCPPCompiler.__init__(self, ccache, exelist, version, for_machine, is_cross,
-                                info, linker=linker, full_version=full_version)
+                                env, linker=linker, full_version=full_version)
         ClangCompiler.__init__(self, defines)
         default_warn_args = ['-Wall', '-Winvalid-pch']
         self.warn_args = {'0': [],
diff --git a/mesonbuild/compilers/rust.py b/mesonbuild/compilers/rust.py
index 8d5a0b5dc..55c58b56a 100644
--- a/mesonbuild/compilers/rust.py
+++ b/mesonbuild/compilers/rust.py
@@ -18,7 +18,6 @@ from .compilers import Compiler, CompileCheckMode, clike_debug_args, is_library
 
 if T.TYPE_CHECKING:
     from ..options import MutableKeyedOptionDictType
-    from ..envconfig import MachineInfo
     from ..environment import Environment  # noqa: F401
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -99,10 +98,10 @@ class RustCompiler(Compiler):
     }
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
+                 is_cross: bool, env: Environment,
                  full_version: T.Optional[str] = None,
                  linker: T.Optional['DynamicLinker'] = None):
-        super().__init__([], exelist, version, for_machine, info,
+        super().__init__([], exelist, version, for_machine, env,
                          is_cross=is_cross, full_version=full_version,
                          linker=linker)
         self.rustup_run_and_args: T.Optional[T.Tuple[T.List[str], T.List[str]]] = get_rustup_run_and_args(exelist)
@@ -463,7 +462,8 @@ class RustCompiler(Compiler):
             return None
 
         return RustdocTestCompiler(exelist, self.version, self.for_machine,
-                                   self.is_cross, self.info, full_version=self.full_version,
+                                   self.is_cross, self.environment,
+                                   full_version=self.full_version,
                                    linker=self.linker, rustc=self)
 
     def enable_env_set_args(self) -> T.Optional[T.List[str]]:
@@ -494,11 +494,10 @@ class RustdocTestCompiler(RustCompiler):
     id = 'rustdoc --test'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo',
-                 full_version: T.Optional[str],
+                 is_cross: bool, env: Environment, full_version: T.Optional[str],
                  linker: T.Optional['DynamicLinker'], rustc: RustCompiler):
         super().__init__(exelist, version, for_machine,
-                         is_cross, info, full_version, linker)
+                         is_cross, env, full_version, linker)
         self.rustc = rustc
 
     @functools.lru_cache(maxsize=None)
diff --git a/mesonbuild/compilers/swift.py b/mesonbuild/compilers/swift.py
index 4ad3affb5..80c104bdb 100644
--- a/mesonbuild/compilers/swift.py
+++ b/mesonbuild/compilers/swift.py
@@ -16,7 +16,6 @@ if T.TYPE_CHECKING:
     from .. import build
     from ..options import MutableKeyedOptionDictType
     from ..dependencies import Dependency
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..linkers.linkers import DynamicLinker
     from ..mesonlib import MachineChoice
@@ -38,9 +37,9 @@ class SwiftCompiler(Compiler):
     id = 'llvm'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo', full_version: T.Optional[str] = None,
+                 is_cross: bool, env: Environment, full_version: T.Optional[str] = None,
                  linker: T.Optional['DynamicLinker'] = None):
-        super().__init__([], exelist, version, for_machine, info,
+        super().__init__([], exelist, version, for_machine, env,
                          is_cross=is_cross, full_version=full_version,
                          linker=linker)
         self.version = version
diff --git a/mesonbuild/compilers/vala.py b/mesonbuild/compilers/vala.py
index a3a196093..da05f88d2 100644
--- a/mesonbuild/compilers/vala.py
+++ b/mesonbuild/compilers/vala.py
@@ -14,7 +14,6 @@ from .compilers import CompileCheckMode, Compiler
 
 if T.TYPE_CHECKING:
     from ..arglist import CompilerArgs
-    from ..envconfig import MachineInfo
     from ..environment import Environment
     from ..mesonlib import MachineChoice
     from ..dependencies import Dependency
@@ -26,8 +25,8 @@ class ValaCompiler(Compiler):
     id = 'valac'
 
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
-                 is_cross: bool, info: 'MachineInfo'):
-        super().__init__([], exelist, version, for_machine, info, is_cross=is_cross)
+                 is_cross: bool, environment: Environment):
+        super().__init__([], exelist, version, for_machine, environment, is_cross=is_cross)
         self.version = version
         self.base_options = {OptionKey('b_colorout')}
         self.force_link = False