Purge `is_cross` and friends without changing user interfaces

In most cases instead pass `for_machine`, the name of the relevant
machines (what compilers target, what targets run on, etc). This allows
us to use the cross code path in the native case, deduplicating the
code.

As one can see, environment got bigger as more information is kept
structured there, while ninjabackend got a smaller. Overall a few amount
of lines were added, but the hope is what's added is a lot simpler than
what's removed.

1 files changed, 100 insertions, 128 deletions

diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
index f8603f6..ce78162 100644
--- a/mesonbuild/environment.py
+++ b/mesonbuild/environment.py
@@ -510,22 +510,6 @@ class Environment:
         self.default_cmake = ['cmake']
         self.default_pkgconfig = ['pkg-config']
 
-        # Various prefixes and suffixes for import libraries, shared libraries,
-        # static libraries, and executables.
-        # Versioning is added to these names in the backends as-needed.
-        if mesonlib.for_windows(self):
-            self.exe_suffix = 'exe'
-            self.object_suffix = 'obj'
-            self.win_libdir_layout = True
-        elif mesonlib.for_cygwin(self):
-            self.exe_suffix = 'exe'
-            self.object_suffix = 'o'
-            self.win_libdir_layout = True
-        else:
-            self.exe_suffix = ''
-            self.object_suffix = 'o'
-            self.win_libdir_layout = False
-
     def create_new_coredata(self, options):
         # WARNING: Don't use any values from coredata in __init__. It gets
         # re-initialized with project options by the interpreter during
@@ -631,17 +615,11 @@ class Environment:
             return CompilerType.GCC_CYGWIN
         return CompilerType.GCC_STANDARD
 
-    def _get_compilers(self, lang, want_cross):
+    def _get_compilers(self, lang, for_machine):
         '''
         The list of compilers is detected in the exact same way for
         C, C++, ObjC, ObjC++, Fortran, CS so consolidate it here.
         '''
-
-        # This morally assumes `want_cross = !native`. It may not yet be
-        # consistently set that way in the non cross build case, but it doesn't
-        # really matter since both options are the same in that case.
-        for_machine = MachineChoice.HOST if want_cross else MachineChoice.BUILD
-
         value = self.binaries[for_machine].lookup_entry(lang)
         if value is not None:
             compilers, ccache = BinaryTable.parse_entry(value)
@@ -654,13 +632,11 @@ class Environment:
             ccache = BinaryTable.detect_ccache()
 
         if self.machines.matches_build_machine(for_machine):
-            is_cross = False
             exe_wrap = None
         else:
-            is_cross = True
             exe_wrap = self.get_exe_wrapper()
 
-        return compilers, ccache, is_cross, exe_wrap
+        return compilers, ccache, exe_wrap
 
     def _handle_exceptions(self, exceptions, binaries, bintype='compiler'):
         errmsg = 'Unknown {}(s): {}'.format(bintype, binaries)
@@ -670,9 +646,10 @@ class Environment:
                 errmsg += '\nRunning "{0}" gave "{1}"'.format(c, e)
         raise EnvironmentException(errmsg)
 
-    def _detect_c_or_cpp_compiler(self, lang, want_cross):
+    def _detect_c_or_cpp_compiler(self, lang, for_machine):
         popen_exceptions = {}
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers(lang, want_cross)
+        compilers, ccache, exe_wrap = self._get_compilers(lang, for_machine)
+        is_cross = not self.machines.matches_build_machine(for_machine)
 
         for compiler in compilers:
             if isinstance(compiler, str):
@@ -737,7 +714,7 @@ class Environment:
                 else:
                     version = self.get_gnu_version_from_defines(defines)
                     cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, defines, full_version=full_version)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, defines, full_version=full_version)
 
             if 'armclang' in out:
                 # The compiler version is not present in the first line of output,
@@ -755,7 +732,7 @@ class Environment:
                 full_version = arm_ver_str
                 compiler_type = CompilerType.ARM_WIN
                 cls = ArmclangCCompiler if lang == 'c' else ArmclangCPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
             if 'CL.EXE COMPATIBILITY' in out:
                 # if this is clang-cl masquerading as cl, detect it as cl, not
                 # clang
@@ -771,21 +748,22 @@ class Environment:
                 else:
                     target = 'unknown target'
                 cls = ClangClCCompiler if lang == 'c' else ClangClCPPCompiler
-                return cls(compiler, version, is_cross, exe_wrap, target)
+                return cls(compiler, version, for_machine, is_cross, exe_wrap, target)
             if 'clang' in out:
-                if 'Apple' in out or mesonlib.for_darwin(self):
+                if 'Apple' in out or self.machines[for_machine].is_darwin():
                     compiler_type = CompilerType.CLANG_OSX
-                elif 'windows' in out or mesonlib.for_windows(self):
+                elif 'windows' in out or self.machines[for_machine].is_windows():
                     compiler_type = CompilerType.CLANG_MINGW
                 else:
                     compiler_type = CompilerType.CLANG_STANDARD
                 cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
             if 'Intel(R) C++ Intel(R)' in err:
                 version = search_version(err)
                 target = 'x86' if 'IA-32' in err else 'x86_64'
                 cls = IntelClCCompiler if lang == 'c' else IntelClCPPCompiler
-                return cls(compiler, version, is_cross, exe_wrap, target)
+                return cls(compiler, version, for_machine, is_cross, exe_wrap, target)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
             if 'Microsoft' in out or 'Microsoft' in err:
                 # Latest versions of Visual Studio print version
                 # number to stderr but earlier ones print version
@@ -804,8 +782,7 @@ class Environment:
                 else:
                     target = 'x86'
                 cls = VisualStudioCCompiler if lang == 'c' else VisualStudioCPPCompiler
-                return cls(compiler, version, is_cross, exe_wrap, target)
-
+                return cls(compiler, version, for_machine, is_cross, exe_wrap, target)
             if 'PGI Compilers' in out:
                 if self.machines[for_machine].is_darwin():
                     compiler_type = CompilerType.PGI_OSX
@@ -814,37 +791,37 @@ class Environment:
                 else:
                     compiler_type = CompilerType.PGI_STANDARD
                 cls = PGICCompiler if lang == 'c' else PGICPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, compiler_type, exe_wrap)
             if '(ICC)' in out:
-                if self.machine[for_macine].is_darwin():
+                if self.machines[for_machine].is_darwin():
                     compiler_type = CompilerType.ICC_OSX
-                elif mesonlib.for_windows(want_cross, self):
+                elif self.machines[for_machine].is_windows():
                     # TODO: fix ICC on Windows
                     compiler_type = CompilerType.ICC_WIN
                 else:
                     compiler_type = CompilerType.ICC_STANDARD
                 cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
             if 'ARM' in out:
                 compiler_type = CompilerType.ARM_WIN
                 cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
             if 'RX Family' in out:
                 compiler_type = CompilerType.CCRX_WIN
                 cls = CcrxCCompiler if lang == 'c' else CcrxCPPCompiler
-                return cls(ccache + compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+                return cls(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
 
         self._handle_exceptions(popen_exceptions, compilers)
 
-    def detect_c_compiler(self, want_cross):
-        return self._detect_c_or_cpp_compiler('c', want_cross)
+    def detect_c_compiler(self, for_machine):
+        return self._detect_c_or_cpp_compiler('c', for_machine)
 
-    def detect_cpp_compiler(self, want_cross):
-        return self._detect_c_or_cpp_compiler('cpp', want_cross)
+    def detect_cpp_compiler(self, for_machine):
+        return self._detect_c_or_cpp_compiler('cpp', for_machine)
 
-    def detect_cuda_compiler(self, want_cross):
+    def detect_cuda_compiler(self, for_machine):
         popen_exceptions = {}
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers('cuda', want_cross)
+        compilers, ccache, exe_wrap = self._get_compilers('cuda', for_machine)
         for compiler in compilers:
             if isinstance(compiler, str):
                 compiler = [compiler]
@@ -873,12 +850,13 @@ class Environment:
             # the full version:
             version = out.strip().split('V')[-1]
             cls = CudaCompiler
-            return cls(ccache + compiler, version, is_cross, exe_wrap)
+            return cls(ccache + compiler, version, for_machine, exe_wrap)
         raise EnvironmentException('Could not find suitable CUDA compiler: "' + ' '.join(compilers) + '"')
 
-    def detect_fortran_compiler(self, want_cross):
+    def detect_fortran_compiler(self, for_machine):
         popen_exceptions = {}
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers('fortran', want_cross)
+        compilers, ccache, exe_wrap = self._get_compilers('fortran', for_machine)
+        is_cross = not self.machines.matches_build_machine(for_machine)
         for compiler in compilers:
             if isinstance(compiler, str):
                 compiler = [compiler]
@@ -910,14 +888,14 @@ class Environment:
                     else:
                         version = self.get_gnu_version_from_defines(defines)
                         cls = GnuFortranCompiler
-                    return cls(compiler, version, compiler_type, is_cross, exe_wrap, defines, full_version=full_version)
+                    return cls(compiler, version, compiler_type, for_machine, is_cross, exe_wrap, defines, full_version=full_version)
 
                 if 'G95' in out:
-                    return G95FortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return G95FortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'Sun Fortran' in err:
                     version = search_version(err)
-                    return SunFortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return SunFortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'Intel(R) Visual Fortran' in err:
                     version = search_version(err)
@@ -925,36 +903,37 @@ class Environment:
                     return IntelClFortranCompiler(compiler, version, is_cross, target, exe_wrap)
 
                 if 'ifort (IFORT)' in out:
-                    return IntelFortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return IntelFortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'PathScale EKOPath(tm)' in err:
-                    return PathScaleFortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return PathScaleFortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'PGI Compilers' in out:
-                    if self.machine[for_macine].is_darwin():
+                    if self.machine[for_machine].is_darwin():
                         compiler_type = CompilerType.PGI_OSX
                     elif self.machines[for_machine].is_windows():
                         compiler_type = CompilerType.PGI_WIN
                     else:
                         compiler_type = CompilerType.PGI_STANDARD
-                    return PGIFortranCompiler(compiler, version, compiler_type, is_cross, exe_wrap, full_version=full_version)
+                    return PGIFortranCompiler(compiler, version, compiler_type, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'flang' in out or 'clang' in out:
-                    return FlangFortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return FlangFortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'Open64 Compiler Suite' in err:
-                    return Open64FortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return Open64FortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
 
                 if 'NAG Fortran' in err:
-                    return NAGFortranCompiler(compiler, version, is_cross, exe_wrap, full_version=full_version)
+                    return NAGFortranCompiler(compiler, version, for_machine, is_cross, exe_wrap, full_version=full_version)
         self._handle_exceptions(popen_exceptions, compilers)
 
     def get_scratch_dir(self):
         return self.scratch_dir
 
-    def detect_objc_compiler(self, want_cross):
+    def detect_objc_compiler(self, for_machine):
         popen_exceptions = {}
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers('objc', want_cross)
+        compilers, ccache, exe_wrap = self._get_compilers('objc', for_machine)
+        is_cross = not self.machines.matches_build_machine(for_machine)
         for compiler in compilers:
             if isinstance(compiler, str):
                 compiler = [compiler]
@@ -972,18 +951,19 @@ class Environment:
                     continue
                 compiler_type = self.get_gnu_compiler_type(defines)
                 version = self.get_gnu_version_from_defines(defines)
-                return GnuObjCCompiler(ccache + compiler, version, compiler_type, is_cross, exe_wrap, defines)
+                return GnuObjCCompiler(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, defines)
             if out.startswith('Apple LLVM'):
-                return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_OSX, is_cross, exe_wrap)
+                return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_OSX, for_machine, is_cross, exe_wrap)
             if 'windows' in out:
-                return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_MINGW, is_cross, exe_wrap)
+                return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_MINGW, for_machine, is_cross, exe_wrap)
             if out.startswith(('clang', 'OpenBSD clang')):
-                return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_STANDARD, is_cross, exe_wrap)
+                return ClangObjCCompiler(ccache + compiler, version, CompilerType.CLANG_STANDARD, for_machine, is_cross, exe_wrap)
         self._handle_exceptions(popen_exceptions, compilers)
 
-    def detect_objcpp_compiler(self, want_cross):
+    def detect_objcpp_compiler(self, for_machine):
         popen_exceptions = {}
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers('objcpp', want_cross)
+        compilers, ccache, exe_wrap = self._get_compilers('objcpp', for_machine)
+        is_cross = not self.machines.matches_build_machine(for_machine)
         for compiler in compilers:
             if isinstance(compiler, str):
                 compiler = [compiler]
@@ -1001,16 +981,16 @@ class Environment:
                     continue
                 compiler_type = self.get_gnu_compiler_type(defines)
                 version = self.get_gnu_version_from_defines(defines)
-                return GnuObjCPPCompiler(ccache + compiler, version, compiler_type, is_cross, exe_wrap, defines)
+                return GnuObjCPPCompiler(ccache + compiler, version, compiler_type, for_machine, is_cross, exe_wrap, defines)
             if out.startswith('Apple LLVM'):
-                return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_OSX, is_cross, exe_wrap)
+                return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_OSX, for_machine, is_cross, exe_wrap)
             if 'windows' in out:
-                return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_MINGW, is_cross, exe_wrap)
+                return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_MINGW, for_machine, is_cross, exe_wrap)
             if out.startswith(('clang', 'OpenBSD clang')):
-                return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_STANDARD, is_cross, exe_wrap)
+                return ClangObjCPPCompiler(ccache + compiler, version, CompilerType.CLANG_STANDARD, for_machine, is_cross, exe_wrap)
         self._handle_exceptions(popen_exceptions, compilers)
 
-    def detect_java_compiler(self):
+    def detect_java_compiler(self, for_machine):
         exelist = self.binaries.host.lookup_entry('java')
         if exelist is None:
             # TODO support fallback
@@ -1026,11 +1006,11 @@ class Environment:
                 parts = (err if 'javac' in err else out).split()
                 if len(parts) > 1:
                     version = parts[1]
-            return JavaCompiler(exelist, version)
+            return JavaCompiler(exelist, version, for_machine)
         raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
 
-    def detect_cs_compiler(self):
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers('cs', False)
+    def detect_cs_compiler(self, for_machine):
+        compilers, ccache, exe_wrap = self._get_compilers('cs', for_machine)
         popen_exceptions = {}
         for comp in compilers:
             if not isinstance(comp, list):
@@ -1043,14 +1023,15 @@ class Environment:
 
             version = search_version(out)
             if 'Mono' in out:
-                return MonoCompiler(comp, version)
+                return MonoCompiler(comp, version, for_machine)
             elif "Visual C#" in out:
-                return VisualStudioCsCompiler(comp, version)
+                return VisualStudioCsCompiler(comp, version, for_machine)
 
         self._handle_exceptions(popen_exceptions, compilers)
 
-    def detect_vala_compiler(self):
+    def detect_vala_compiler(self, for_machine):
         exelist = self.binaries.host.lookup_entry('vala')
+        is_cross = not self.machines.matches_build_machine(for_machine)
         if exelist is None:
             # TODO support fallback
             exelist = [self.default_vala[0]]
@@ -1061,12 +1042,13 @@ class Environment:
             raise EnvironmentException('Could not execute Vala compiler "%s"' % ' '.join(exelist))
         version = search_version(out)
         if 'Vala' in out:
-            return ValaCompiler(exelist, version)
+            return ValaCompiler(exelist, version, for_machine, is_cross)
         raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
 
-    def detect_rust_compiler(self, want_cross):
+    def detect_rust_compiler(self, for_machine):
         popen_exceptions = {}
-        compilers, ccache, is_cross, exe_wrap = self._get_compilers('rust', want_cross)
+        compilers, ccache, exe_wrap = self._get_compilers('rust', for_machine)
+        is_cross = not self.machines.matches_build_machine(for_machine)
         for compiler in compilers:
             if isinstance(compiler, str):
                 compiler = [compiler]
@@ -1080,13 +1062,12 @@ class Environment:
             version = search_version(out)
 
             if 'rustc' in out:
-                return RustCompiler(compiler, version, is_cross, exe_wrap)
+                return RustCompiler(compiler, version, for_machine, is_cross, exe_wrap)
 
         self._handle_exceptions(popen_exceptions, compilers)
 
-    def detect_d_compiler(self, want_cross):
-        is_cross = want_cross and self.is_cross_build()
-        exelist = self.binaries.host.lookup_entry('d')
+    def detect_d_compiler(self, for_machine: MachineChoice):
+        exelist = self.binaries[for_machine].lookup_entry('d')
         # Search for a D compiler.
         # We prefer LDC over GDC unless overridden with the DC
         # environment variable because LDC has a much more
@@ -1115,22 +1096,23 @@ class Environment:
         c_compiler = {}
         is_msvc = mesonlib.is_windows() and 'VCINSTALLDIR' in os.environ
         if is_msvc:
-            c_compiler = {'c': self.detect_c_compiler(want_cross)} # MSVC compiler is required for correct platform detection.
+            c_compiler = {'c': self.detect_c_compiler(for_machine)} # MSVC compiler is required for correct platform detection.
 
         arch = detect_cpu_family(c_compiler)
         if is_msvc and arch == 'x86':
             arch = 'x86_mscoff'
 
         if 'LLVM D compiler' in out:
-            return compilers.LLVMDCompiler(exelist, version, is_cross, arch, full_version=full_version)
+            return compilers.LLVMDCompiler(exelist, version, for_machine, arch, full_version=full_version)
         elif 'gdc' in out:
-            return compilers.GnuDCompiler(exelist, version, is_cross, arch, full_version=full_version)
+            return compilers.GnuDCompiler(exelist, version, for_machine, arch, full_version=full_version)
         elif 'The D Language Foundation' in out or 'Digital Mars' in out:
-            return compilers.DmdDCompiler(exelist, version, is_cross, arch, full_version=full_version)
+            return compilers.DmdDCompiler(exelist, version, for_machine, arch, full_version=full_version)
         raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
 
-    def detect_swift_compiler(self):
+    def detect_swift_compiler(self, for_machine):
         exelist = self.binaries.host.lookup_entry('swift')
+        is_cross = not self.machines.matches_build_machine(for_machine)
         if exelist is None:
             # TODO support fallback
             exelist = [self.default_swift[0]]
@@ -1141,53 +1123,47 @@ class Environment:
             raise EnvironmentException('Could not execute Swift compiler "%s"' % ' '.join(exelist))
         version = search_version(err)
         if 'Swift' in err:
-            return compilers.SwiftCompiler(exelist, version)
+            return compilers.SwiftCompiler(exelist, version, for_machine, is_cross)
         raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
 
-    def compiler_from_language(self, lang: str, want_cross: bool):
+    def compiler_from_language(self, lang: str, for_machine: MachineChoice):
         if lang == 'c':
-            comp = self.detect_c_compiler(want_cross)
+            comp = self.detect_c_compiler(for_machine)
         elif lang == 'cpp':
-            comp = self.detect_cpp_compiler(want_cross)
+            comp = self.detect_cpp_compiler(for_machine)
         elif lang == 'objc':
-            comp = self.detect_objc_compiler(want_cross)
+            comp = self.detect_objc_compiler(for_machine)
         elif lang == 'cuda':
-            comp = self.detect_cuda_compiler(want_cross)
+            comp = self.detect_cuda_compiler(for_machine)
         elif lang == 'objcpp':
-            comp = self.detect_objcpp_compiler(want_cross)
+            comp = self.detect_objcpp_compiler(for_machine)
         elif lang == 'java':
-            comp = self.detect_java_compiler()  # Java is platform independent.
+            comp = self.detect_java_compiler(for_machine)
         elif lang == 'cs':
-            comp = self.detect_cs_compiler()  # C# is platform independent.
+            comp = self.detect_cs_compiler(for_machine)
         elif lang == 'vala':
-            comp = self.detect_vala_compiler()  # Vala compiles to platform-independent C
+            comp = self.detect_vala_compiler(for_machine)
         elif lang == 'd':
-            comp = self.detect_d_compiler(want_cross)
+            comp = self.detect_d_compiler(for_machine)
         elif lang == 'rust':
-            comp = self.detect_rust_compiler(want_cross)
+            comp = self.detect_rust_compiler(for_machine)
         elif lang == 'fortran':
-            comp = self.detect_fortran_compiler(want_cross)
+            comp = self.detect_fortran_compiler(for_machine)
         elif lang == 'swift':
-            if want_cross:
-                raise EnvironmentException('Cross compilation with Swift is not working yet.')
-            comp = self.detect_swift_compiler()
+            comp = self.detect_swift_compiler(for_machine)
         else:
             comp = None
         return comp
 
-    def detect_compilers(self, lang: str, need_cross_compiler: bool):
-        comp = self.compiler_from_language(lang, False)
-        if need_cross_compiler:
-            cross_comp = self.compiler_from_language(lang, True)
-        else:
-            cross_comp = None
+    def detect_compiler_for(self, lang: str, for_machine: MachineChoice):
+        comp = self.compiler_from_language(lang, for_machine)
         if comp is not None:
-            self.coredata.process_new_compilers(lang, comp, cross_comp, self)
-        return comp, cross_comp
+            assert comp.for_machine == for_machine
+            self.coredata.process_new_compiler(lang, comp, self)
+        return comp
 
     def detect_static_linker(self, compiler):
-        for_machine = MachineChoice.HOST if compiler.is_cross else MachineChoice.BUILD
-        linker = self.binaries[for_machine].lookup_entry('ar')
+        linker = self.binaries[compiler.for_machine].lookup_entry('ar')
         if linker is not None:
             linkers = [linker]
         else:
@@ -1255,9 +1231,6 @@ class Environment:
     def get_build_dir(self):
         return self.build_dir
 
-    def get_exe_suffix(self):
-        return self.exe_suffix
-
     def get_import_lib_dir(self) -> str:
         "Install dir for the import library (library used for linking)"
         return self.get_libdir()
@@ -1268,7 +1241,9 @@ class Environment:
 
     def get_shared_lib_dir(self) -> str:
         "Install dir for the shared library"
-        if self.win_libdir_layout:
+        m = self.machines.host
+        # Windows has no RPATH or similar, so DLLs must be next to EXEs.
+        if m.is_windows() or m.is_cygwin():
             return self.get_bindir()
         return self.get_libdir()
 
@@ -1276,9 +1251,6 @@ class Environment:
         "Install dir for the static library"
         return self.get_libdir()
 
-    def get_object_suffix(self):
-        return self.object_suffix
-
     def get_prefix(self) -> str:
         return self.coredata.get_builtin_option('prefix')
 
@@ -1300,8 +1272,8 @@ class Environment:
     def get_datadir(self) -> str:
         return self.coredata.get_builtin_option('datadir')
 
-    def get_compiler_system_dirs(self):
-        for comp in self.coredata.compilers.values():
+    def get_compiler_system_dirs(self, for_machine: MachineChoice):
+        for comp in self.coredata.compilers[for_machine].values():
             if isinstance(comp, compilers.ClangCompiler):
                 index = 1
                 break