Split compiler detection from Environment

This moves all the compiler detection logic into the new
compilers.detect module. This dramatically reduces the size
and complexity of Environment.

1 files changed, 5 insertions, 1363 deletions

diff --git a/mesonbuild/environment.py b/mesonbuild/environment.py
index 6248c58..df9c7eb 100644
--- a/mesonbuild/environment.py
+++ b/mesonbuild/environment.py
@@ -13,18 +13,16 @@
 # limitations under the License.
 
 import itertools
-import os, platform, re, sys, shutil, subprocess
-import tempfile
-import shlex
+import os, platform, re, sys, shutil
 import typing as T
 import collections
 
 from . import coredata
-from .linkers import ArLinker, ArmarLinker, VisualStudioLinker, DLinker, CcrxLinker, Xc16Linker, CompCertLinker, C2000Linker, IntelVisualStudioLinker, AIXArLinker
 from . import mesonlib
 from .mesonlib import (
     MesonException, EnvironmentException, MachineChoice, Popen_safe, PerMachine,
-    PerMachineDefaultable, PerThreeMachineDefaultable, split_args, quote_arg, OptionKey
+    PerMachineDefaultable, PerThreeMachineDefaultable, split_args, quote_arg, OptionKey,
+    search_version
 )
 from . import mlog
 from .programs import (
@@ -44,93 +42,8 @@ from .compilers import (
     is_object,
     is_source,
 )
-from .linkers import (
-    AppleDynamicLinker,
-    ArmClangDynamicLinker,
-    ArmDynamicLinker,
-    CcrxDynamicLinker,
-    Xc16DynamicLinker,
-    CompCertDynamicLinker,
-    C2000DynamicLinker,
-    ClangClDynamicLinker,
-    DynamicLinker,
-    GnuBFDDynamicLinker,
-    GnuGoldDynamicLinker,
-    LLVMDynamicLinker,
-    QualcommLLVMDynamicLinker,
-    MSVCDynamicLinker,
-    OptlinkDynamicLinker,
-    NvidiaHPC_DynamicLinker,
-    NvidiaHPC_StaticLinker,
-    PGIDynamicLinker,
-    PGIStaticLinker,
-    SolarisDynamicLinker,
-    AIXDynamicLinker,
-    XilinkDynamicLinker,
-    CudaLinker,
-    VisualStudioLikeLinkerMixin,
-    WASMDynamicLinker,
-)
+
 from functools import lru_cache
-from .compilers import (
-    ArmCCompiler,
-    ArmCPPCompiler,
-    ArmclangCCompiler,
-    ArmclangCPPCompiler,
-    AppleClangCCompiler,
-    AppleClangCPPCompiler,
-    AppleClangObjCCompiler,
-    AppleClangObjCPPCompiler,
-    ClangCCompiler,
-    ClangCPPCompiler,
-    ClangObjCCompiler,
-    ClangObjCPPCompiler,
-    ClangClCCompiler,
-    ClangClCPPCompiler,
-    CythonCompiler,
-    FlangFortranCompiler,
-    G95FortranCompiler,
-    GnuCCompiler,
-    GnuCPPCompiler,
-    GnuFortranCompiler,
-    GnuObjCCompiler,
-    GnuObjCPPCompiler,
-    ElbrusCCompiler,
-    ElbrusCPPCompiler,
-    ElbrusFortranCompiler,
-    EmscriptenCCompiler,
-    EmscriptenCPPCompiler,
-    IntelCCompiler,
-    IntelClCCompiler,
-    IntelCPPCompiler,
-    IntelClCPPCompiler,
-    IntelFortranCompiler,
-    IntelClFortranCompiler,
-    JavaCompiler,
-    MonoCompiler,
-    CudaCompiler,
-    VisualStudioCsCompiler,
-    NAGFortranCompiler,
-    Open64FortranCompiler,
-    PathScaleFortranCompiler,
-    NvidiaHPC_CCompiler,
-    NvidiaHPC_CPPCompiler,
-    NvidiaHPC_FortranCompiler,
-    PGICCompiler,
-    PGICPPCompiler,
-    PGIFortranCompiler,
-    RustCompiler,
-    CcrxCCompiler,
-    CcrxCPPCompiler,
-    Xc16CCompiler,
-    CompCertCCompiler,
-    C2000CCompiler,
-    C2000CPPCompiler,
-    SunFortranCompiler,
-    ValaCompiler,
-    VisualStudioCCompiler,
-    VisualStudioCPPCompiler,
-)
 from mesonbuild import envconfig
 
 if T.TYPE_CHECKING:
@@ -211,7 +124,7 @@ def detect_ninja(version: str = '1.8.2', log: bool = False) -> T.List[str]:
     r = detect_ninja_command_and_version(version, log)
     return r[0] if r else None
 
-def detect_ninja_command_and_version(version: str = '1.8.2', log: bool = False) -> (T.List[str], str):
+def detect_ninja_command_and_version(version: str = '1.8.2', log: bool = False) -> T.Tuple[T.List[str], str]:
     env_ninja = os.environ.get('NINJA', None)
     for n in [env_ninja] if env_ninja else ['ninja', 'ninja-build', 'samu']:
         prog = ExternalProgram(n, silent=True)
@@ -520,49 +433,6 @@ def machine_info_can_run(machine_info: MachineInfo):
         ((true_build_cpu_family == 'x86_64') and (machine_info.cpu_family == 'x86')) or \
         ((true_build_cpu_family == 'aarch64') and (machine_info.cpu_family == 'arm'))
 
-def search_version(text: str) -> str:
-    # Usually of the type 4.1.4 but compiler output may contain
-    # stuff like this:
-    # (Sourcery CodeBench Lite 2014.05-29) 4.8.3 20140320 (prerelease)
-    # Limiting major version number to two digits seems to work
-    # thus far. When we get to GCC 100, this will break, but
-    # if we are still relevant when that happens, it can be
-    # considered an achievement in itself.
-    #
-    # This regex is reaching magic levels. If it ever needs
-    # to be updated, do not complexify but convert to something
-    # saner instead.
-    # We'll demystify it a bit with a verbose definition.
-    version_regex = re.compile(r"""
-    (?<!                # Zero-width negative lookbehind assertion
-        (
-            \d          # One digit
-            | \.        # Or one period
-        )               # One occurrence
-    )
-    # Following pattern must not follow a digit or period
-    (
-        \d{1,2}         # One or two digits
-        (
-            \.\d+       # Period and one or more digits
-        )+              # One or more occurrences
-        (
-            -[a-zA-Z0-9]+   # Hyphen and one or more alphanumeric
-        )?              # Zero or one occurrence
-    )                   # One occurrence
-    """, re.VERBOSE)
-    match = version_regex.search(text)
-    if match:
-        return match.group(0)
-
-    # try a simpler regex that has like "blah 2020.01.100 foo" or "blah 2020.01 foo"
-    version_regex = re.compile(r"(\d{1,4}\.\d{1,4}\.?\d{0,4})")
-    match = version_regex.search(text)
-    if match:
-        return match.group(0)
-
-    return 'unknown version'
-
 class Environment:
     private_dir = 'meson-private'
     log_dir = 'meson-logs'
@@ -699,50 +569,6 @@ class Environment:
         else:
             self.exe_wrapper = None
 
-        # List of potential compilers.
-        if mesonlib.is_windows():
-            # Intel C and C++ compiler is icl on Windows, but icc and icpc elsewhere.
-            # Search for icl before cl, since Intel "helpfully" provides a
-            # cl.exe that returns *exactly the same thing* that microsofts
-            # cl.exe does, and if icl is present, it's almost certainly what
-            # you want.
-            self.default_c = ['icl', 'cl', 'cc', 'gcc', 'clang', 'clang-cl', 'pgcc']
-            # There is currently no pgc++ for Windows, only for  Mac and Linux.
-            self.default_cpp = ['icl', 'cl', 'c++', 'g++', 'clang++', 'clang-cl']
-            self.default_fortran = ['ifort', 'gfortran', 'flang', 'pgfortran', 'g95']
-            # Clang and clang++ are valid, but currently unsupported.
-            self.default_objc = ['cc', 'gcc']
-            self.default_objcpp = ['c++', 'g++']
-            self.default_cs = ['csc', 'mcs']
-        else:
-            if platform.machine().lower() == 'e2k':
-                # There are no objc or objc++ compilers for Elbrus,
-                # and there's no clang which can build binaries for host.
-                self.default_c = ['cc', 'gcc', 'lcc']
-                self.default_cpp = ['c++', 'g++', 'l++']
-                self.default_objc = []
-                self.default_objcpp = []
-            else:
-                self.default_c = ['cc', 'gcc', 'clang', 'nvc', 'pgcc', 'icc']
-                self.default_cpp = ['c++', 'g++', 'clang++', 'nvc++', 'pgc++', 'icpc']
-                self.default_objc = ['cc', 'gcc', 'clang']
-                self.default_objcpp = ['c++', 'g++', 'clang++']
-            self.default_fortran = ['gfortran', 'flang', 'nvfortran', 'pgfortran', 'ifort', 'g95']
-            self.default_cs = ['mcs', 'csc']
-        self.default_d = ['ldc2', 'ldc', 'gdc', 'dmd']
-        self.default_java = ['javac']
-        self.default_cuda = ['nvcc']
-        self.default_rust = ['rustc']
-        self.default_swift = ['swiftc']
-        self.default_vala = ['valac']
-        self.default_cython = [['cython']]
-        self.default_static_linker = ['ar', 'gar']
-        self.default_strip = ['strip']
-        self.vs_static_linker = ['lib']
-        self.clang_cl_static_linker = ['llvm-lib']
-        self.cuda_static_linker = ['nvlink']
-        self.gcc_static_linker = ['gcc-ar']
-        self.clang_static_linker = ['llvm-ar']
         self.default_cmake = ['cmake']
         self.default_pkgconfig = ['pkg-config']
         self.wrap_resolver = None
@@ -952,1193 +778,9 @@ class Environment:
     def lookup_binary_entry(self, for_machine: MachineChoice, name: str) -> T.Optional[T.List[str]]:
         return self.binaries[for_machine].lookup_entry(name)
 
-    @staticmethod
-    def get_gnu_compiler_defines(compiler):
-        """
-        Detect GNU compiler platform type (Apple, MinGW, Unix)
-        """
-        # Arguments to output compiler pre-processor defines to stdout
-        # gcc, g++, and gfortran all support these arguments
-        args = compiler + ['-E', '-dM', '-']
-        p, output, error = Popen_safe(args, write='', stdin=subprocess.PIPE)
-        if p.returncode != 0:
-            raise EnvironmentException('Unable to detect GNU compiler type:\n' + output + error)
-        # Parse several lines of the type:
-        # `#define ___SOME_DEF some_value`
-        # and extract `___SOME_DEF`
-        defines = {}
-        for line in output.split('\n'):
-            if not line:
-                continue
-            d, *rest = line.split(' ', 2)
-            if d != '#define':
-                continue
-            if len(rest) == 1:
-                defines[rest] = True
-            if len(rest) == 2:
-                defines[rest[0]] = rest[1]
-        return defines
-
-    @staticmethod
-    def get_gnu_version_from_defines(defines):
-        dot = '.'
-        major = defines.get('__GNUC__', '0')
-        minor = defines.get('__GNUC_MINOR__', '0')
-        patch = defines.get('__GNUC_PATCHLEVEL__', '0')
-        return dot.join((major, minor, patch))
-
-    @staticmethod
-    def get_lcc_version_from_defines(defines):
-        dot = '.'
-        generation_and_major = defines.get('__LCC__', '100')
-        generation = generation_and_major[:1]
-        major = generation_and_major[1:]
-        minor = defines.get('__LCC_MINOR__', '0')
-        return dot.join((generation, major, minor))
-
-    @staticmethod
-    def get_clang_compiler_defines(compiler):
-        """
-        Get the list of Clang pre-processor defines
-        """
-        args = compiler + ['-E', '-dM', '-']
-        p, output, error = Popen_safe(args, write='', stdin=subprocess.PIPE)
-        if p.returncode != 0:
-            raise EnvironmentException('Unable to get clang pre-processor defines:\n' + output + error)
-        defines = {}
-        for line in output.split('\n'):
-            if not line:
-                continue
-            d, *rest = line.split(' ', 2)
-            if d != '#define':
-                continue
-            if len(rest) == 1:
-                defines[rest] = True
-            if len(rest) == 2:
-                defines[rest[0]] = rest[1]
-        return defines
-
-    def _get_compilers(self, lang: str, for_machine: MachineChoice) -> T.Tuple[T.List[T.List[str]], T.List[str], T.Optional['ExternalProgram']]:
-        '''
-        The list of compilers is detected in the exact same way for
-        C, C++, ObjC, ObjC++, Fortran, CS so consolidate it here.
-        '''
-        value = self.lookup_binary_entry(for_machine, lang)
-        if value is not None:
-            compilers, ccache = BinaryTable.parse_entry(value)
-            # Return value has to be a list of compiler 'choices'
-            compilers = [compilers]
-        else:
-            if not self.machines.matches_build_machine(for_machine):
-                raise EnvironmentException(f'{lang!r} compiler binary not defined in cross or native file')
-            compilers = getattr(self, 'default_' + lang)
-            ccache = BinaryTable.detect_ccache()
-
-        if self.machines.matches_build_machine(for_machine):
-            exe_wrap = None
-        else:
-            exe_wrap = self.get_exe_wrapper()
-
-        return compilers, ccache, exe_wrap
-
-    def _handle_exceptions(self, exceptions, binaries, bintype='compiler'):
-        errmsg = f'Unknown {bintype}(s): {binaries}'
-        if exceptions:
-            errmsg += '\nThe following exception(s) were encountered:'
-            for (c, e) in exceptions.items():
-                errmsg += f'\nRunning "{c}" gave "{e}"'
-        raise EnvironmentException(errmsg)
-
-    @staticmethod
-    def __failed_to_detect_linker(compiler: T.List[str], args: T.List[str], stdout: str, stderr: str) -> 'T.NoReturn':
-        msg = 'Unable to detect linker for compiler "{} {}"\nstdout: {}\nstderr: {}'.format(
-            ' '.join(compiler), ' '.join(args), stdout, stderr)
-        raise EnvironmentException(msg)
-
-    def _guess_win_linker(self, compiler: T.List[str], comp_class: Compiler,
-                          for_machine: MachineChoice, *,
-                          use_linker_prefix: bool = True, invoked_directly: bool = True,
-                          extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
-        self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
-
-        # Explicitly pass logo here so that we can get the version of link.exe
-        if not use_linker_prefix or comp_class.LINKER_PREFIX is None:
-            check_args = ['/logo', '--version']
-        elif isinstance(comp_class.LINKER_PREFIX, str):
-            check_args = [comp_class.LINKER_PREFIX + '/logo', comp_class.LINKER_PREFIX + '--version']
-        elif isinstance(comp_class.LINKER_PREFIX, list):
-            check_args = comp_class.LINKER_PREFIX + ['/logo'] + comp_class.LINKER_PREFIX + ['--version']
-
-        check_args += self.coredata.options[OptionKey('args', lang=comp_class.language, machine=for_machine)].value
-
-        override = []  # type: T.List[str]
-        value = self.lookup_binary_entry(for_machine, comp_class.language + '_ld')
-        if value is not None:
-            override = comp_class.use_linker_args(value[0])
-            check_args += override
-
-        if extra_args is not None:
-            check_args.extend(extra_args)
-
-        p, o, _ = Popen_safe(compiler + check_args)
-        if o.startswith('LLD'):
-            if '(compatible with GNU linkers)' in o:
-                return LLVMDynamicLinker(
-                    compiler, for_machine, comp_class.LINKER_PREFIX,
-                    override, version=search_version(o))
-            elif not invoked_directly:
-                return ClangClDynamicLinker(
-                    for_machine, override, exelist=compiler, prefix=comp_class.LINKER_PREFIX,
-                    version=search_version(o), direct=False, machine=None)
-
-        if value is not None and invoked_directly:
-            compiler = value
-            # We've already hanedled the non-direct case above
-
-        p, o, e = Popen_safe(compiler + check_args)
-        if o.startswith('LLD'):
-            return ClangClDynamicLinker(
-                for_machine, [],
-                prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
-                exelist=compiler, version=search_version(o), direct=invoked_directly)
-        elif 'OPTLINK' in o:
-            # Opltink's stdout *may* beging with a \r character.
-            return OptlinkDynamicLinker(compiler, for_machine, version=search_version(o))
-        elif o.startswith('Microsoft') or e.startswith('Microsoft'):
-            out = o or e
-            match = re.search(r'.*(X86|X64|ARM|ARM64).*', out)
-            if match:
-                target = str(match.group(1))
-            else:
-                target = 'x86'
-
-            return MSVCDynamicLinker(
-                for_machine, [], machine=target, exelist=compiler,
-                prefix=comp_class.LINKER_PREFIX if use_linker_prefix else [],
-                version=search_version(out), direct=invoked_directly)
-        elif 'GNU coreutils' in o:
-            raise EnvironmentException(
-                "Found GNU link.exe instead of MSVC link.exe. This link.exe "
-                "is not a linker. You may need to reorder entries to your "
-                "%PATH% variable to resolve this.")
-        self.__failed_to_detect_linker(compiler, check_args, o, e)
-
-    def _guess_nix_linker(self, compiler: T.List[str], comp_class: T.Type[Compiler],
-                          for_machine: MachineChoice, *,
-                          extra_args: T.Optional[T.List[str]] = None) -> 'DynamicLinker':
-        """Helper for guessing what linker to use on Unix-Like OSes.
-
-        :compiler: Invocation to use to get linker
-        :comp_class: The Compiler Type (uninstantiated)
-        :for_machine: which machine this linker targets
-        :extra_args: Any additional arguments required (such as a source file)
-        """
-        self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
-        extra_args = extra_args or []
-        extra_args += self.coredata.options[OptionKey('args', lang=comp_class.language, machine=for_machine)].value
-
-        if isinstance(comp_class.LINKER_PREFIX, str):
-            check_args = [comp_class.LINKER_PREFIX + '--version'] + extra_args
-        else:
-            check_args = comp_class.LINKER_PREFIX + ['--version'] + extra_args
-
-        override = []  # type: T.List[str]
-        value = self.lookup_binary_entry(for_machine, comp_class.language + '_ld')
-        if value is not None:
-            override = comp_class.use_linker_args(value[0])
-            check_args += override
-
-        _, o, e = Popen_safe(compiler + check_args)
-        v = search_version(o + e)
-        if o.startswith('LLD'):
-            linker = LLVMDynamicLinker(
-                compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)  # type: DynamicLinker
-        elif 'Snapdragon' in e and 'LLVM' in e:
-            linker = QualcommLLVMDynamicLinker(
-                compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)  # type: DynamicLinker
-        elif e.startswith('lld-link: '):
-            # The LLD MinGW frontend didn't respond to --version before version 9.0.0,
-            # and produced an error message about failing to link (when no object
-            # files were specified), instead of printing the version number.
-            # Let's try to extract the linker invocation command to grab the version.
-
-            _, o, e = Popen_safe(compiler + check_args + ['-v'])
-
-            try:
-                linker_cmd = re.match(r'.*\n(.*?)\nlld-link: ', e, re.DOTALL).group(1)
-                linker_cmd = shlex.split(linker_cmd)[0]
-            except (AttributeError, IndexError, ValueError):
-                pass
-            else:
-                _, o, e = Popen_safe([linker_cmd, '--version'])
-                v = search_version(o)
-
-            linker = LLVMDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
-        # first is for apple clang, second is for real gcc, the third is icc
-        elif e.endswith('(use -v to see invocation)\n') or 'macosx_version' in e or 'ld: unknown option:' in e:
-            if isinstance(comp_class.LINKER_PREFIX, str):
-                _, _, e = Popen_safe(compiler + [comp_class.LINKER_PREFIX + '-v'] + extra_args)
-            else:
-                _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-v'] + extra_args)
-            for line in e.split('\n'):
-                if 'PROJECT:ld' in line:
-                    v = line.split('-')[1]
-                    break
-            else:
-                v = 'unknown version'
-            linker = AppleDynamicLinker(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
-        elif 'GNU' in o or 'GNU' in e:
-            if 'gold' in o or 'gold' in e:
-                cls = GnuGoldDynamicLinker
-            else:
-                cls = GnuBFDDynamicLinker
-            linker = cls(compiler, for_machine, comp_class.LINKER_PREFIX, override, version=v)
-        elif 'Solaris' in e or 'Solaris' in o:
-            for line in (o+e).split('\n'):
-                if 'ld: Software Generation Utilities' in line:
-                    v = line.split(':')[2].lstrip()
-                    break
-            else:
-                v = 'unknown version'
-            linker = SolarisDynamicLinker(
-                compiler, for_machine, comp_class.LINKER_PREFIX, override,
-                version=v)
-        elif 'ld: 0706-012 The -- flag is not recognized' in e:
-            if isinstance(comp_class.LINKER_PREFIX, str):
-                _, _, e = Popen_safe(compiler + [comp_class.LINKER_PREFIX + '-V'] + extra_args)
-            else:
-                _, _, e = Popen_safe(compiler + comp_class.LINKER_PREFIX + ['-V'] + extra_args)
-            linker = AIXDynamicLinker(
-                compiler, for_machine, comp_class.LINKER_PREFIX, override,
-                version=search_version(e))
-        else:
-            self.__failed_to_detect_linker(compiler, check_args, o, e)
-        return linker
-
-    def _detect_c_or_cpp_compiler(self, lang: str, for_machine: MachineChoice, *, override_compiler: T.Optional[T.List[str]] = None) -> Compiler:
-        """Shared implementation for finding the C or C++ compiler to use.
-
-        the override_compiler option is provided to allow compilers which use
-        the compiler (GCC or Clang usually) as their shared linker, to find
-        the linker they need.
-        """
-        popen_exceptions = {}
-        compilers, ccache, exe_wrap = self._get_compilers(lang, for_machine)
-        if override_compiler is not None:
-            compilers = [override_compiler]
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-
-        for compiler in compilers:
-            if isinstance(compiler, str):
-                compiler = [compiler]
-            compiler_name = os.path.basename(compiler[0])
-
-            if not {'cl', 'cl.exe', 'clang-cl', 'clang-cl.exe'}.isdisjoint(compiler):
-                # Watcom C provides it's own cl.exe clone that mimics an older
-                # version of Microsoft's compiler. Since Watcom's cl.exe is
-                # just a wrapper, we skip using it if we detect its presence
-                # so as not to confuse Meson when configuring for MSVC.
-                #
-                # Additionally the help text of Watcom's cl.exe is paged, and
-                # the binary will not exit without human intervention. In
-                # practice, Meson will block waiting for Watcom's cl.exe to
-                # exit, which requires user input and thus will never exit.
-                if 'WATCOM' in os.environ:
-                    def sanitize(p):
-                        return os.path.normcase(os.path.abspath(p))
-
-                    watcom_cls = [sanitize(os.path.join(os.environ['WATCOM'], 'BINNT', 'cl')),
-                                  sanitize(os.path.join(os.environ['WATCOM'], 'BINNT', 'cl.exe'))]
-                    found_cl = sanitize(shutil.which('cl'))
-                    if found_cl in watcom_cls:
-                        continue
-                arg = '/?'
-            elif 'armcc' in compiler_name:
-                arg = '--vsn'
-            elif 'ccrx' in compiler_name:
-                arg = '-v'
-            elif 'xc16' in compiler_name:
-                arg = '--version'
-            elif 'ccomp' in compiler_name:
-                arg = '-version'
-            elif 'cl2000' in compiler_name:
-                arg = '-version'
-            elif compiler_name in {'icl', 'icl.exe'}:
-                # if you pass anything to icl you get stuck in a pager
-                arg = ''
-            else:
-                arg = '--version'
-
-            try:
-                p, out, err = Popen_safe(compiler + [arg])
-            except OSError as e:
-                popen_exceptions[' '.join(compiler + [arg])] = e
-                continue
-
-            if 'ccrx' in compiler_name:
-                out = err
-
-            full_version = out.split('\n', 1)[0]
-            version = search_version(out)
-
-            guess_gcc_or_lcc = False
-            if 'Free Software Foundation' in out or 'xt-' in out:
-                guess_gcc_or_lcc = 'gcc'
-            if 'e2k' in out and 'lcc' in out:
-                guess_gcc_or_lcc = 'lcc'
-            if 'Microchip Technology' in out:
-                # this output has "Free Software Foundation" in its version
-                guess_gcc_or_lcc = False
-
-            if guess_gcc_or_lcc:
-                defines = self.get_gnu_compiler_defines(compiler)
-                if not defines:
-                    popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
-                    continue
-
-                if guess_gcc_or_lcc == 'lcc':
-                    version = self.get_lcc_version_from_defines(defines)
-                    cls = ElbrusCCompiler if lang == 'c' else ElbrusCPPCompiler
-                else:
-                    version = self.get_gnu_version_from_defines(defines)
-                    cls = GnuCCompiler if lang == 'c' else GnuCPPCompiler
-
-                linker = self._guess_nix_linker(compiler, cls, for_machine)
-
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross,
-                    info, exe_wrap, defines=defines, full_version=full_version,
-                    linker=linker)
-
-            if 'Emscripten' in out:
-                cls = EmscriptenCCompiler if lang == 'c' else EmscriptenCPPCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-
-                # emcc requires a file input in order to pass arguments to the
-                # linker. It'll exit with an error code, but still print the
-                # linker version. Old emcc versions ignore -Wl,--version completely,
-                # however. We'll report "unknown version" in that case.
-                with tempfile.NamedTemporaryFile(suffix='.c') as f:
-                    cmd = compiler + [cls.LINKER_PREFIX + "--version", f.name]
-                    _, o, _ = Popen_safe(cmd)
-
-                linker = WASMDynamicLinker(
-                    compiler, for_machine, cls.LINKER_PREFIX,
-                    [], version=search_version(o))
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, linker=linker, full_version=full_version)
-
-            if 'armclang' in out:
-                # The compiler version is not present in the first line of output,
-                # instead it is present in second line, startswith 'Component:'.
-                # So, searching for the 'Component' in out although we know it is
-                # present in second line, as we are not sure about the
-                # output format in future versions
-                arm_ver_str = re.search('.*Component.*', out)
-                if arm_ver_str is None:
-                    popen_exceptions[' '.join(compiler)] = 'version string not found'
-                    continue
-                arm_ver_str = arm_ver_str.group(0)
-                # Override previous values
-                version = search_version(arm_ver_str)
-                full_version = arm_ver_str
-                cls = ArmclangCCompiler if lang == 'c' else ArmclangCPPCompiler
-                linker = ArmClangDynamicLinker(for_machine, version=version)
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, 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
-                # clang
-                arg = '--version'
-                try:
-                    p, out, err = Popen_safe(compiler + [arg])
-                except OSError as e:
-                    popen_exceptions[' '.join(compiler + [arg])] = e
-                version = search_version(out)
-                match = re.search('^Target: (.*?)-', out, re.MULTILINE)
-                if match:
-                    target = match.group(1)
-                else:
-                    target = 'unknown target'
-                cls = ClangClCCompiler if lang == 'c' else ClangClCPPCompiler
-                linker = self._guess_win_linker(['lld-link'], cls, for_machine)
-                return cls(
-                    compiler, version, for_machine, is_cross, info, target,
-                    exe_wrap, linker=linker)
-            if 'clang' in out or 'Clang' in out:
-                linker = None
-
-                defines = self.get_clang_compiler_defines(compiler)
-
-                # Even if the for_machine is darwin, we could be using vanilla
-                # clang.
-                if 'Apple' in out:
-                    cls = AppleClangCCompiler if lang == 'c' else AppleClangCPPCompiler
-                else:
-                    cls = ClangCCompiler if lang == 'c' else ClangCPPCompiler
-
-                if 'windows' in out or self.machines[for_machine].is_windows():
-                    # If we're in a MINGW context this actually will use a gnu
-                    # style ld, but for clang on "real" windows we'll use
-                    # either link.exe or lld-link.exe
-                    try:
-                        linker = self._guess_win_linker(compiler, cls, for_machine, invoked_directly=False)
-                    except MesonException:
-                        pass
-                if linker is None:
-                    linker = self._guess_nix_linker(compiler, cls, for_machine)
-
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, defines=defines, full_version=full_version, linker=linker)
-
-            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
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = XilinkDynamicLinker(for_machine, [], version=version)
-                return cls(
-                    compiler, version, for_machine, is_cross, info, target,
-                    exe_wrap, linker=linker)
-            if 'Microsoft' in out or 'Microsoft' in err:
-                # Latest versions of Visual Studio print version
-                # number to stderr but earlier ones print version
-                # on stdout.  Why? Lord only knows.
-                # Check both outputs to figure out version.
-                for lookat in [err, out]:
-                    version = search_version(lookat)
-                    if version != 'unknown version':
-                        break
-                else:
-                    m = 'Failed to detect MSVC compiler version: stderr was\n{!r}'
-                    raise EnvironmentException(m.format(err))
-                cl_signature = lookat.split('\n')[0]
-                match = re.search(r'.*(x86|x64|ARM|ARM64)([^_A-Za-z0-9]|$)', cl_signature)
-                if match:
-                    target = match.group(1)
-                else:
-                    m = 'Failed to detect MSVC compiler target architecture: \'cl /?\' output is\n{}'
-                    raise EnvironmentException(m.format(cl_signature))
-                cls = VisualStudioCCompiler if lang == 'c' else VisualStudioCPPCompiler
-                linker = self._guess_win_linker(['link'], cls, for_machine)
-                return cls(
-                    compiler, version, for_machine, is_cross, info, target,
-                    exe_wrap, full_version=cl_signature, linker=linker)
-            if 'PGI Compilers' in out:
-                cls = PGICCompiler if lang == 'c' else PGICPPCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = PGIDynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross,
-                    info, exe_wrap, linker=linker)
-            if 'NVIDIA Compilers and Tools' in out:
-                cls = NvidiaHPC_CCompiler if lang == 'c' else NvidiaHPC_CPPCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = NvidiaHPC_DynamicLinker(compiler, for_machine, cls.LINKER_PREFIX, [], version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross,
-                    info, exe_wrap, linker=linker)
-            if '(ICC)' in out:
-                cls = IntelCCompiler if lang == 'c' else IntelCPPCompiler
-                l = self._guess_nix_linker(compiler, cls, for_machine)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, full_version=full_version, linker=l)
-            if 'ARM' in out:
-                cls = ArmCCompiler if lang == 'c' else ArmCPPCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = ArmDynamicLinker(for_machine, version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross,
-                    info, exe_wrap, full_version=full_version, linker=linker)
-            if 'RX Family' in out:
-                cls = CcrxCCompiler if lang == 'c' else CcrxCPPCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = CcrxDynamicLinker(for_machine, version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, full_version=full_version, linker=linker)
-
-            if 'Microchip Technology' in out:
-                cls = Xc16CCompiler if lang == 'c' else Xc16CCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = Xc16DynamicLinker(for_machine, version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, full_version=full_version, linker=linker)
-
-            if 'CompCert' in out:
-                cls = CompCertCCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = CompCertDynamicLinker(for_machine, version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, full_version=full_version, linker=linker)
-
-            if 'TMS320C2000 C/C++' in out:
-                cls = C2000CCompiler if lang == 'c' else C2000CPPCompiler
-                self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                linker = C2000DynamicLinker(for_machine, version=version)
-                return cls(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, full_version=full_version, linker=linker)
-
-
-        self._handle_exceptions(popen_exceptions, compilers)
-
-    def detect_c_compiler(self, for_machine):
-        return self._detect_c_or_cpp_compiler('c', for_machine)
-
-    def detect_cpp_compiler(self, for_machine):
-        return self._detect_c_or_cpp_compiler('cpp', for_machine)
-
-    def detect_cuda_compiler(self, for_machine):
-        popen_exceptions = {}
-        is_cross = self.is_cross_build(for_machine)
-        compilers, ccache, exe_wrap = self._get_compilers('cuda', for_machine)
-        info = self.machines[for_machine]
-        for compiler in compilers:
-            if isinstance(compiler, str):
-                compiler = [compiler]
-            arg = '--version'
-            try:
-                p, out, err = Popen_safe(compiler + [arg])
-            except OSError as e:
-                popen_exceptions[' '.join(compiler + [arg])] = e
-                continue
-            # Example nvcc printout:
-            #
-            #     nvcc: NVIDIA (R) Cuda compiler driver
-            #     Copyright (c) 2005-2018 NVIDIA Corporation
-            #     Built on Sat_Aug_25_21:08:01_CDT_2018
-            #     Cuda compilation tools, release 10.0, V10.0.130
-            #
-            # search_version() first finds the "10.0" after "release",
-            # rather than the more precise "10.0.130" after "V".
-            # The patch version number is occasionally important; For
-            # instance, on Linux,
-            #    - CUDA Toolkit 8.0.44 requires NVIDIA Driver 367.48
-            #    - CUDA Toolkit 8.0.61 requires NVIDIA Driver 375.26
-            # Luckily, the "V" also makes it very simple to extract
-            # the full version:
-            version = out.strip().split('V')[-1]
-            cpp_compiler = self.detect_cpp_compiler(for_machine)
-            cls = CudaCompiler
-            self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-            linker = CudaLinker(compiler, for_machine, CudaCompiler.LINKER_PREFIX, [], version=CudaLinker.parse_version())
-            return cls(ccache + compiler, version, for_machine, is_cross, exe_wrap, host_compiler=cpp_compiler, info=info, linker=linker)
-        raise EnvironmentException('Could not find suitable CUDA compiler: "' + ' '.join(compilers) + '"')
-
-    def detect_fortran_compiler(self, for_machine: MachineChoice):
-        popen_exceptions = {}
-        compilers, ccache, exe_wrap = self._get_compilers('fortran', for_machine)
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-        for compiler in compilers:
-            if isinstance(compiler, str):
-                compiler = [compiler]
-            for arg in ['--version', '-V']:
-                try:
-                    p, out, err = Popen_safe(compiler + [arg])
-                except OSError as e:
-                    popen_exceptions[' '.join(compiler + [arg])] = e
-                    continue
-
-                version = search_version(out)
-                full_version = out.split('\n', 1)[0]
-
-                guess_gcc_or_lcc = False
-                if 'GNU Fortran' in out:
-                    guess_gcc_or_lcc = 'gcc'
-                if 'e2k' in out and 'lcc' in out:
-                    guess_gcc_or_lcc = 'lcc'
-
-                if guess_gcc_or_lcc:
-                    defines = self.get_gnu_compiler_defines(compiler)
-                    if not defines:
-                        popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
-                        continue
-                    if guess_gcc_or_lcc == 'lcc':
-                        version = self.get_lcc_version_from_defines(defines)
-                        cls = ElbrusFortranCompiler
-                    else:
-                        version = self.get_gnu_version_from_defines(defines)
-                        cls = GnuFortranCompiler
-                    linker = self._guess_nix_linker(
-                        compiler, cls, for_machine)
-                    return cls(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, defines, full_version=full_version,
-                        linker=linker)
-
-                if 'G95' in out:
-                    linker = self._guess_nix_linker(
-                        compiler, cls, for_machine)
-                    return G95FortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version, linker=linker)
-
-                if 'Sun Fortran' in err:
-                    version = search_version(err)
-                    linker = self._guess_nix_linker(
-                        compiler, cls, for_machine)
-                    return SunFortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version, linker=linker)
-
-                if 'Intel(R) Visual Fortran' in err:
-                    version = search_version(err)
-                    target = 'x86' if 'IA-32' in err else 'x86_64'
-                    cls = IntelClFortranCompiler
-                    self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                    linker = XilinkDynamicLinker(for_machine, [], version=version)
-                    return cls(
-                        compiler, version, for_machine, is_cross, info,
-                        target, exe_wrap, linker=linker)
-
-                if 'ifort (IFORT)' in out:
-                    linker = self._guess_nix_linker(compiler, IntelFortranCompiler, for_machine)
-                    return IntelFortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version, linker=linker)
-
-                if 'PathScale EKOPath(tm)' in err:
-                    return PathScaleFortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version)
-
-                if 'PGI Compilers' in out:
-                    cls = PGIFortranCompiler
-                    self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                    linker = PGIDynamicLinker(compiler, for_machine,
-                                              cls.LINKER_PREFIX, [], version=version)
-                    return cls(
-                        compiler, version, for_machine, is_cross, info, exe_wrap,
-                        full_version=full_version, linker=linker)
-
-                if 'NVIDIA Compilers and Tools' in out:
-                    cls = NvidiaHPC_FortranCompiler
-                    self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-                    linker = PGIDynamicLinker(compiler, for_machine,
-                                              cls.LINKER_PREFIX, [], version=version)
-                    return cls(
-                        compiler, version, for_machine, is_cross, info, exe_wrap,
-                        full_version=full_version, linker=linker)
-
-                if 'flang' in out or 'clang' in out:
-                    linker = self._guess_nix_linker(
-                        compiler, FlangFortranCompiler, for_machine)
-                    return FlangFortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version, linker=linker)
-
-                if 'Open64 Compiler Suite' in err:
-                    linker = self._guess_nix_linker(
-                        compiler, Open64FortranCompiler, for_machine)
-                    return Open64FortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version, linker=linker)
-
-                if 'NAG Fortran' in err:
-                    linker = self._guess_nix_linker(
-                        compiler, NAGFortranCompiler, for_machine)
-                    return NAGFortranCompiler(
-                        compiler, version, for_machine, is_cross, info,
-                        exe_wrap, full_version=full_version, linker=linker)
-
-        self._handle_exceptions(popen_exceptions, compilers)
-
     def get_scratch_dir(self) -> str:
         return self.scratch_dir
 
-    def detect_objc_compiler(self, for_machine: MachineChoice) -> 'Compiler':
-        return self._detect_objc_or_objcpp_compiler(for_machine, True)
-
-    def detect_objcpp_compiler(self, for_machine: MachineChoice) -> 'Compiler':
-        return self._detect_objc_or_objcpp_compiler(for_machine, False)
-
-    def _detect_objc_or_objcpp_compiler(self, for_machine: MachineChoice, objc: bool) -> 'Compiler':
-        popen_exceptions = {}
-        compilers, ccache, exe_wrap = self._get_compilers('objc' if objc else 'objcpp', for_machine)
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-
-        for compiler in compilers:
-            if isinstance(compiler, str):
-                compiler = [compiler]
-            arg = ['--version']
-            try:
-                p, out, err = Popen_safe(compiler + arg)
-            except OSError as e:
-                popen_exceptions[' '.join(compiler + arg)] = e
-                continue
-            version = search_version(out)
-            if 'Free Software Foundation' in out:
-                defines = self.get_gnu_compiler_defines(compiler)
-                if not defines:
-                    popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
-                    continue
-                version = self.get_gnu_version_from_defines(defines)
-                comp = GnuObjCCompiler if objc else GnuObjCPPCompiler
-                linker = self._guess_nix_linker(compiler, comp, for_machine)
-                return comp(
-                    ccache + compiler, version, for_machine, is_cross, info,
-                    exe_wrap, defines, linker=linker)
-            if 'clang' in out:
-                linker = None
-                defines = self.get_clang_compiler_defines(compiler)
-                if not defines:
-                    popen_exceptions[' '.join(compiler)] = 'no pre-processor defines'
-                    continue
-                if 'Apple' in out:
-                    comp = AppleClangObjCCompiler if objc else AppleClangObjCPPCompiler
-                else:
-                    comp = ClangObjCCompiler if objc else ClangObjCPPCompiler
-                if 'windows' in out or self.machines[for_machine].is_windows():
-                    # If we're in a MINGW context this actually will use a gnu style ld
-                    try:
-                        linker = self._guess_win_linker(compiler, comp, for_machine)
-                    except MesonException:
-                        pass
-
-                if not linker:
-                    linker = self._guess_nix_linker(
-                        compiler, comp, for_machine)
-                return comp(
-                    ccache + compiler, version, for_machine,
-                    is_cross, info, exe_wrap, linker=linker, defines=defines)
-        self._handle_exceptions(popen_exceptions, compilers)
-
-    def detect_java_compiler(self, for_machine):
-        exelist = self.lookup_binary_entry(for_machine, 'java')
-        info = self.machines[for_machine]
-        if exelist is None:
-            # TODO support fallback
-            exelist = [self.default_java[0]]
-
-        try:
-            p, out, err = Popen_safe(exelist + ['-version'])
-        except OSError:
-            raise EnvironmentException('Could not execute Java compiler "{}"'.format(' '.join(exelist)))
-        if 'javac' in out or 'javac' in err:
-            version = search_version(err if 'javac' in err else out)
-            if not version or version == 'unknown version':
-                parts = (err if 'javac' in err else out).split()
-                if len(parts) > 1:
-                    version = parts[1]
-            comp_class = JavaCompiler
-            self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
-            return comp_class(exelist, version, for_machine, info)
-        raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
-    def detect_cs_compiler(self, for_machine):
-        compilers, ccache, exe_wrap = self._get_compilers('cs', for_machine)
-        popen_exceptions = {}
-        info = self.machines[for_machine]
-        for comp in compilers:
-            if not isinstance(comp, list):
-                comp = [comp]
-            try:
-                p, out, err = Popen_safe(comp + ['--version'])
-            except OSError as e:
-                popen_exceptions[' '.join(comp + ['--version'])] = e
-                continue
-
-            version = search_version(out)
-            if 'Mono' in out:
-                cls = MonoCompiler
-            elif "Visual C#" in out:
-                cls = VisualStudioCsCompiler
-            else:
-                continue
-            self.coredata.add_lang_args(cls.language, cls, for_machine, self)
-            return cls(comp, version, for_machine, info)
-
-        self._handle_exceptions(popen_exceptions, compilers)
-
-    def detect_cython_compiler(self, for_machine: MachineChoice) -> CythonCompiler:
-        """Search for a cython compiler."""
-        compilers = self.lookup_binary_entry(for_machine, 'cython')
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-        if compilers is None:
-            # TODO support fallback
-            compilers = [self.default_cython[0]]
-
-        popen_exceptions: T.Dict[str, Exception] = {}
-        for comp in compilers:
-            try:
-                err = Popen_safe(comp + ['-V'])[2]
-            except OSError as e:
-                popen_exceptions[' '.join(comp + ['-V'])] = e
-                continue
-
-            version = search_version(err)
-            if 'Cython' in err:
-                comp_class = CythonCompiler
-                self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
-                return comp_class(comp, version, for_machine, info, is_cross=is_cross)
-        self._handle_exceptions(popen_exceptions, compilers)
-
-    def detect_vala_compiler(self, for_machine):
-        exelist = self.lookup_binary_entry(for_machine, 'vala')
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-        if exelist is None:
-            # TODO support fallback
-            exelist = [self.default_vala[0]]
-
-        try:
-            p, out = Popen_safe(exelist + ['--version'])[0:2]
-        except OSError:
-            raise EnvironmentException('Could not execute Vala compiler "{}"'.format(' '.join(exelist)))
-        version = search_version(out)
-        if 'Vala' in out:
-            comp_class = ValaCompiler
-            self.coredata.add_lang_args(comp_class.language, comp_class, for_machine, self)
-            return comp_class(exelist, version, for_machine, info, is_cross)
-        raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
-    def detect_rust_compiler(self, for_machine: MachineChoice) -> RustCompiler:
-        popen_exceptions = {}  # type: T.Dict[str, Exception]
-        compilers, _, exe_wrap = self._get_compilers('rust', for_machine)
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-
-        cc = self.detect_c_compiler(for_machine)
-        is_link_exe = isinstance(cc.linker, VisualStudioLikeLinkerMixin)
-        override = self.lookup_binary_entry(for_machine, 'rust_ld')
-
-        for compiler in compilers:
-            if isinstance(compiler, str):
-                compiler = [compiler]
-            arg = ['--version']
-            try:
-                out = Popen_safe(compiler + arg)[1]
-            except OSError as e:
-                popen_exceptions[' '.join(compiler + arg)] = e
-                continue
-
-            version = search_version(out)
-
-            if 'rustc' in out:
-                # On Linux and mac rustc will invoke gcc (clang for mac
-                # presumably) and it can do this windows, for dynamic linking.
-                # this means the easiest way to C compiler for dynamic linking.
-                # figure out what linker to use is to just get the value of the
-                # C compiler and use that as the basis of the rust linker.
-                # However, there are two things we need to change, if CC is not
-                # the default use that, and second add the necessary arguments
-                # to rust to use -fuse-ld
-
-                if any(a.startswith('linker=') for a in compiler):
-                    mlog.warning(
-                        'Please do not put -C linker= in your compiler '
-                        'command, set rust_ld=command in your cross file '
-                        'or use the RUST_LD environment variable, otherwise meson '
-                        'will override your selection.')
-
-                if override is None:
-                    extra_args = {}
-                    always_args = []
-                    if is_link_exe:
-                        compiler.extend(RustCompiler.use_linker_args(cc.linker.exelist[0]))
-                        extra_args['direct'] = True
-                        extra_args['machine'] = cc.linker.machine
-                    else:
-                        exelist = cc.linker.exelist.copy()
-                        if 'ccache' in exelist[0]:
-                            del exelist[0]
-                        c = exelist.pop(0)
-                        compiler.extend(RustCompiler.use_linker_args(c))
-
-                        # Also ensure that we pass any extra arguments to the linker
-                        for l in exelist:
-                            compiler.extend(['-C', f'link-arg={l}'])
-
-                    # This trickery with type() gets us the class of the linker
-                    # so we can initialize a new copy for the Rust Compiler
-                    if is_link_exe:
-                        linker = type(cc.linker)(for_machine, always_args, exelist=cc.linker.exelist,
-                                                 version=cc.linker.version, **extra_args)
-                    else:
-                        linker = type(cc.linker)(compiler, for_machine, cc.LINKER_PREFIX,
-                                                 always_args=always_args, version=cc.linker.version,
-                                                 **extra_args)
-                elif 'link' in override[0]:
-                    linker = self._guess_win_linker(
-                        override, RustCompiler, for_machine, use_linker_prefix=False)
-                    # rustc takes linker arguments without a prefix, and
-                    # inserts the correct prefix itself.
-                    linker.direct = True
-                    compiler.extend(RustCompiler.use_linker_args(linker.exelist[0]))
-                else:
-                    # On linux and macos rust will invoke the c compiler for
-                    # linking, on windows it will use lld-link or link.exe.
-                    # we will simply ask for the C compiler that corresponds to
-                    # it, and use that.
-                    cc = self._detect_c_or_cpp_compiler('c', for_machine, override_compiler=override)
-                    linker = cc.linker
-
-                    # Of course, we're not going to use any of that, we just
-                    # need it to get the proper arguments to pass to rustc
-                    c = linker.exelist[1] if linker.exelist[0].endswith('ccache') else linker.exelist[0]
-                    compiler.extend(RustCompiler.use_linker_args(c))
-
-                self.coredata.add_lang_args(RustCompiler.language, RustCompiler, for_machine, self)
-                return RustCompiler(
-                    compiler, version, for_machine, is_cross, info, exe_wrap,
-                    linker=linker)
-
-        self._handle_exceptions(popen_exceptions, compilers)
-
-    def detect_d_compiler(self, for_machine: MachineChoice):
-        info = self.machines[for_machine]
-
-        # Detect the target architecture, required for proper architecture handling on Windows.
-        # MSVC compiler is required for correct platform detection.
-        c_compiler = {'c': self.detect_c_compiler(for_machine)}
-        is_msvc = isinstance(c_compiler['c'], VisualStudioCCompiler)
-        if not is_msvc:
-            c_compiler = {}
-
-        arch = detect_cpu_family(c_compiler)
-        if is_msvc and arch == 'x86':
-            arch = 'x86_mscoff'
-
-        popen_exceptions = {}
-        is_cross = self.is_cross_build(for_machine)
-        results, ccache, exe_wrap = self._get_compilers('d', for_machine)
-        for exelist in results:
-            # Search for a D compiler.
-            # We prefer LDC over GDC unless overridden with the DC
-            # environment variable because LDC has a much more
-            # up to date language version at time (2016).
-            if not isinstance(exelist, list):
-                exelist = [exelist]
-            if os.path.basename(exelist[-1]).startswith(('ldmd', 'gdmd')):
-                raise EnvironmentException(
-                    'Meson does not support {} as it is only a DMD frontend for another compiler.'
-                    'Please provide a valid value for DC or unset it so that Meson can resolve the compiler by itself.'.format(exelist[-1]))
-            try:
-                p, out = Popen_safe(exelist + ['--version'])[0:2]
-            except OSError as e:
-                popen_exceptions[' '.join(exelist + ['--version'])] = e
-                continue
-            version = search_version(out)
-            full_version = out.split('\n', 1)[0]
-
-            if 'LLVM D compiler' in out:
-                # LDC seems to require a file
-                # We cannot use NamedTemproraryFile on windows, its documented
-                # to not work for our uses. So, just use mkstemp and only have
-                # one path for simplicity.
-                o, f = tempfile.mkstemp('.d')
-                os.close(o)
-
-                try:
-                    if info.is_windows() or info.is_cygwin():
-                        objfile = os.path.basename(f)[:-1] + 'obj'
-                        linker = self._guess_win_linker(
-                            exelist,
-                            compilers.LLVMDCompiler, for_machine,
-                            use_linker_prefix=True, invoked_directly=False,
-                            extra_args=[f])
-                    else:
-                        # LDC writes an object file to the current working directory.
-                        # Clean it up.
-                        objfile = os.path.basename(f)[:-1] + 'o'
-                        linker = self._guess_nix_linker(
-                            exelist, compilers.LLVMDCompiler, for_machine,
-                            extra_args=[f])
-                finally:
-                    mesonlib.windows_proof_rm(f)
-                    mesonlib.windows_proof_rm(objfile)
-
-                return compilers.LLVMDCompiler(
-                    exelist, version, for_machine, info, arch,
-                    full_version=full_version, linker=linker, version_output=out)
-            elif 'gdc' in out:
-                linker = self._guess_nix_linker(exelist, compilers.GnuDCompiler, for_machine)
-                return compilers.GnuDCompiler(
-                    exelist, version, for_machine, info, arch,
-                    exe_wrapper=exe_wrap, is_cross=is_cross,
-                    full_version=full_version, linker=linker)
-            elif 'The D Language Foundation' in out or 'Digital Mars' in out:
-                # DMD seems to require a file
-                # We cannot use NamedTemproraryFile on windows, its documented
-                # to not work for our uses. So, just use mkstemp and only have
-                # one path for simplicity.
-                o, f = tempfile.mkstemp('.d')
-                os.close(o)
-
-                # DMD as different detection logic for x86 and x86_64
-                arch_arg = '-m64' if arch == 'x86_64' else '-m32'
-
-                try:
-                    if info.is_windows() or info.is_cygwin():
-                        objfile = os.path.basename(f)[:-1] + 'obj'
-                        linker = self._guess_win_linker(
-                            exelist, compilers.DmdDCompiler, for_machine,
-                            invoked_directly=False, extra_args=[f, arch_arg])
-                    else:
-                        objfile = os.path.basename(f)[:-1] + 'o'
-                        linker = self._guess_nix_linker(
-                            exelist, compilers.DmdDCompiler, for_machine,
-                            extra_args=[f, arch_arg])
-                finally:
-                    mesonlib.windows_proof_rm(f)
-                    mesonlib.windows_proof_rm(objfile)
-
-                return compilers.DmdDCompiler(
-                    exelist, version, for_machine, info, arch,
-                    full_version=full_version, linker=linker)
-            raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
-        self._handle_exceptions(popen_exceptions, compilers)
-
-    def detect_swift_compiler(self, for_machine):
-        exelist = self.lookup_binary_entry(for_machine, 'swift')
-        is_cross = self.is_cross_build(for_machine)
-        info = self.machines[for_machine]
-        if exelist is None:
-            # TODO support fallback
-            exelist = [self.default_swift[0]]
-
-        try:
-            p, _, err = Popen_safe(exelist + ['-v'])
-        except OSError:
-            raise EnvironmentException('Could not execute Swift compiler "{}"'.format(' '.join(exelist)))
-        version = search_version(err)
-        if 'Swift' in err:
-            # As for 5.0.1 swiftc *requires* a file to check the linker:
-            with tempfile.NamedTemporaryFile(suffix='.swift') as f:
-                linker = self._guess_nix_linker(
-                    exelist, compilers.SwiftCompiler, for_machine,
-                    extra_args=[f.name])
-            return compilers.SwiftCompiler(
-                exelist, version, for_machine, info, is_cross, linker=linker)
-
-        raise EnvironmentException('Unknown compiler "' + ' '.join(exelist) + '"')
-
-    def compiler_from_language(self, lang: str, for_machine: MachineChoice):
-        if lang == 'c':
-            comp = self.detect_c_compiler(for_machine)
-        elif lang == 'cpp':
-            comp = self.detect_cpp_compiler(for_machine)
-        elif lang == 'objc':
-            comp = self.detect_objc_compiler(for_machine)
-        elif lang == 'cuda':
-            comp = self.detect_cuda_compiler(for_machine)
-        elif lang == 'objcpp':
-            comp = self.detect_objcpp_compiler(for_machine)
-        elif lang == 'java':
-            comp = self.detect_java_compiler(for_machine)
-        elif lang == 'cs':
-            comp = self.detect_cs_compiler(for_machine)
-        elif lang == 'vala':
-            comp = self.detect_vala_compiler(for_machine)
-        elif lang == 'd':
-            comp = self.detect_d_compiler(for_machine)
-        elif lang == 'rust':
-            comp = self.detect_rust_compiler(for_machine)
-        elif lang == 'fortran':
-            comp = self.detect_fortran_compiler(for_machine)
-        elif lang == 'swift':
-            comp = self.detect_swift_compiler(for_machine)
-        elif lang == 'cython':
-            comp = self.detect_cython_compiler(for_machine)
-        else:
-            comp = None
-        return comp
-
-    def detect_compiler_for(self, lang: str, for_machine: MachineChoice):
-        comp = self.compiler_from_language(lang, for_machine)
-        if comp is not None:
-            assert comp.for_machine == for_machine
-            self.coredata.process_new_compiler(lang, comp, self)
-        return comp
-
-    def detect_static_linker(self, compiler):
-        linker = self.lookup_binary_entry(compiler.for_machine, 'ar')
-        if linker is not None:
-            linkers = [linker]
-        else:
-            defaults = [[l] for l in self.default_static_linker]
-            if isinstance(compiler, compilers.CudaCompiler):
-                linkers = [self.cuda_static_linker] + defaults
-            elif isinstance(compiler, compilers.VisualStudioLikeCompiler):
-                linkers = [self.vs_static_linker, self.clang_cl_static_linker]
-            elif isinstance(compiler, compilers.GnuCompiler):
-                # Use gcc-ar if available; needed for LTO
-                linkers = [self.gcc_static_linker] + defaults
-            elif isinstance(compiler, compilers.ClangCompiler):
-                # Use llvm-ar if available; needed for LTO
-                linkers = [self.clang_static_linker] + defaults
-            elif isinstance(compiler, compilers.DCompiler):
-                # Prefer static linkers over linkers used by D compilers
-                if mesonlib.is_windows():
-                    linkers = [self.vs_static_linker, self.clang_cl_static_linker, compiler.get_linker_exelist()]
-                else:
-                    linkers = defaults
-            elif isinstance(compiler, IntelClCCompiler):
-                # Intel has it's own linker that acts like microsoft's lib
-                linkers = ['xilib']
-            elif isinstance(compiler, (PGICCompiler, PGIFortranCompiler)) and mesonlib.is_windows():
-                linkers = [['ar']]  # For PGI on Windows, "ar" is just a wrapper calling link/lib.
-            else:
-                linkers = defaults
-        popen_exceptions = {}
-        for linker in linkers:
-            if not {'lib', 'lib.exe', 'llvm-lib', 'llvm-lib.exe', 'xilib', 'xilib.exe'}.isdisjoint(linker):
-                arg = '/?'
-            elif not {'ar2000', 'ar2000.exe'}.isdisjoint(linker):
-                arg = '?'
-            else:
-                arg = '--version'
-            try:
-                p, out, err = Popen_safe(linker + [arg])
-            except OSError as e:
-                popen_exceptions[' '.join(linker + [arg])] = e
-                continue
-            if "xilib: executing 'lib'" in err:
-                return IntelVisualStudioLinker(linker, getattr(compiler, 'machine', None))
-            if '/OUT:' in out.upper() or '/OUT:' in err.upper():
-                return VisualStudioLinker(linker, getattr(compiler, 'machine', None))
-            if 'ar-Error-Unknown switch: --version' in err:
-                return PGIStaticLinker(linker)
-            if p.returncode == 0 and ('armar' in linker or 'armar.exe' in linker):
-                return ArmarLinker(linker)
-            if 'DMD32 D Compiler' in out or 'DMD64 D Compiler' in out:
-                return DLinker(linker, compiler.arch)
-            if 'LDC - the LLVM D compiler' in out:
-                return DLinker(linker, compiler.arch, rsp_syntax=compiler.rsp_file_syntax())
-            if 'GDC' in out and ' based on D ' in out:
-                return DLinker(linker, compiler.arch)
-            if err.startswith('Renesas') and ('rlink' in linker or 'rlink.exe' in linker):
-                return CcrxLinker(linker)
-            if out.startswith('GNU ar') and ('xc16-ar' in linker or 'xc16-ar.exe' in linker):
-                return Xc16Linker(linker)
-            if out.startswith('TMS320C2000') and ('ar2000' in linker or 'ar2000.exe' in linker):
-                return C2000Linker(linker)
-            if out.startswith('The CompCert'):
-                return CompCertLinker(linker)
-            if p.returncode == 0:
-                return ArLinker(linker)
-            if p.returncode == 1 and err.startswith('usage'): # OSX
-                return ArLinker(linker)
-            if p.returncode == 1 and err.startswith('Usage'): # AIX
-                return AIXArLinker(linker)
-            if p.returncode == 1 and err.startswith('ar: bad option: --'): # Solaris
-                return ArLinker(linker)
-        self._handle_exceptions(popen_exceptions, linkers, 'linker')
-        raise EnvironmentException('Unknown static linker "{}"'.format(' '.join(linkers)))
-
     def get_source_dir(self) -> str:
         return self.source_dir