compilers: Split C-Like functionality into a mixin classes

Currently C++ inherits C, which can lead to diamond problems. By pulling
the code out into a standalone mixin class that the C, C++, ObjC, and
Objc++ compilers can inherit and override as necessary we remove one
source of diamonding. I've chosen to split this out into it's own file
as the CLikeCompiler class is over 1000 lines by itself. This also
breaks the VisualStudio derived classes inheriting from each other, to
avoid the same C -> CPP inheritance problems. This is all one giant
patch because there just isn't a clean way to separate this.

I've done the same for Fortran since it effectively inherits the
CCompiler (I say effectively because was it actually did was gross
beyond explanation), it's probably not correct, but it seems to work for
now. There really is a lot of layering violation going on in the
Compilers, and a really good scrubbing would do this code a lot of good.

mesonbuild/backend/backends.py

@@ -23,7 +23,7 @@ import subprocess
 from ..mesonlib import MachineChoice, MesonException, OrderedSet
 from ..mesonlib import classify_unity_sources
 from ..mesonlib import File
-from ..compilers import CompilerArgs, VisualStudioCCompiler
+from ..compilers import CompilerArgs, VisualStudioLikeCompiler
 from collections import OrderedDict
 import shlex
 from functools import lru_cache
@@ -551,7 +551,7 @@ class Backend:
             return args
         extra_args = []
         # Compiler-specific escaping is needed for -D args but not for any others
-        if isinstance(compiler, VisualStudioCCompiler):
+        if isinstance(compiler, VisualStudioLikeCompiler):
             # MSVC needs escaping when a -D argument ends in \ or \"
             for arg in args:
                 if arg.startswith('-D') or arg.startswith('/D'):

mesonbuild/backend/ninjabackend.py

@@ -29,7 +29,7 @@ from .. import build
 from .. import mlog
 from .. import dependencies
 from .. import compilers
-from ..compilers import CompilerArgs, CCompiler, VisualStudioCCompiler, FortranCompiler
+from ..compilers import CompilerArgs, CCompiler, VisualStudioLikeCompiler, FortranCompiler
 from ..linkers import ArLinker
 from ..mesonlib import File, MachineChoice, MesonException, OrderedSet, LibType
 from ..mesonlib import get_compiler_for_source, has_path_sep
@@ -221,7 +221,7 @@ class NinjaBackend(backends.Backend):
         Detect the search prefix to use.'''
         for compiler in self.build.compilers.values():
             # Have to detect the dependency format
-            if isinstance(compiler, VisualStudioCCompiler):
+            if isinstance(compiler, VisualStudioLikeCompiler):
                 break
         else:
             # None of our compilers are MSVC, we're done.
@@ -1673,7 +1673,7 @@ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485'''))
         command = [ninja_quote(i) for i in compiler.get_exelist()]
         args = ['$ARGS'] + quoted_depargs + compiler.get_output_args('$out') + compiler.get_compile_only_args() + ['$in']
         description = 'Compiling %s object $out.' % compiler.get_display_language()
-        if isinstance(compiler, VisualStudioCCompiler):
+        if isinstance(compiler, VisualStudioLikeCompiler):
             deps = 'msvc'
             depfile = None
         else:
@@ -1698,13 +1698,13 @@ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485'''))
             if d != '$out' and d != '$in':
                 d = quote_func(d)
             quoted_depargs.append(d)
-        if isinstance(compiler, VisualStudioCCompiler):
+        if isinstance(compiler, VisualStudioLikeCompiler):
             output = []
         else:
             output = compiler.get_output_args('$out')
         command = compiler.get_exelist() + ['$ARGS'] + quoted_depargs + output + compiler.get_compile_only_args() + ['$in']
         description = 'Precompiling header $in.'
-        if isinstance(compiler, VisualStudioCCompiler):
+        if isinstance(compiler, VisualStudioLikeCompiler):
             deps = 'msvc'
             depfile = None
         else:
@@ -1886,7 +1886,7 @@ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485'''))
         return compiler.get_no_stdinc_args()
 
     def get_compile_debugfile_args(self, compiler, target, objfile):
-        if not isinstance(compiler, VisualStudioCCompiler):
+        if not isinstance(compiler, VisualStudioLikeCompiler):
             return []
         # The way MSVC uses PDB files is documented exactly nowhere so
         # the following is what we have been able to decipher via
@@ -2275,7 +2275,7 @@ https://gcc.gnu.org/bugzilla/show_bug.cgi?id=47485'''))
                       ''.format(target.get_basename())
                 raise InvalidArguments(msg)
             compiler = target.compilers[lang]
-            if isinstance(compiler, VisualStudioCCompiler):
+            if isinstance(compiler, VisualStudioLikeCompiler):
                 (commands, dep, dst, objs, src) = self.generate_msvc_pch_command(target, compiler, pch)
                 extradep = os.path.join(self.build_to_src, target.get_source_subdir(), pch[0])
             elif compiler.id == 'intel':

mesonbuild/compilers/__init__.py

@@ -89,6 +89,7 @@ __all__ = [
     'SunFortranCompiler',
     'SwiftCompiler',
     'ValaCompiler',
+    'VisualStudioLikeCompiler',
     'VisualStudioCCompiler',
     'VisualStudioCPPCompiler',
 ]
@@ -120,6 +121,7 @@ from .compilers import (
     GnuCompiler,
     IntelCompiler,
     CcrxCompiler,
+    VisualStudioLikeCompiler,
 )
 from .c import (
     CCompiler,

mesonbuild/compilers/compilers.py

@@ -1529,6 +1529,335 @@ def gnulike_default_include_dirs(compiler, lang):
     return paths
 
 
+class VisualStudioLikeCompiler(metaclass=abc.ABCMeta):
+
+    """A common interface for all compilers implementing an MSVC-style
+    interface.
+
+    A number of compilers attempt to mimic MSVC, with varying levels of
+    success, such as Clang-CL and ICL (the Intel C/C++ Compiler for Windows).
+    This classs implements as much common logic as possible.
+    """
+
+    std_warn_args = ['/W3']
+    std_opt_args = ['/O2']
+    ignore_libs = unixy_compiler_internal_libs
+    internal_libs = ()
+
+    crt_args = {'none': [],
+                'md': ['/MD'],
+                'mdd': ['/MDd'],
+                'mt': ['/MT'],
+                'mtd': ['/MTd'],
+                }
+    # /showIncludes is needed for build dependency tracking in Ninja
+    # See: https://ninja-build.org/manual.html#_deps
+    always_args = ['/nologo', '/showIncludes']
+    warn_args = {'0': ['/W1'],
+                 '1': ['/W2'],
+                 '2': ['/W3'],
+                 '3': ['/W4'],
+                 }
+
+    def __init__(self, target: str):
+        self.base_options = ['b_pch', 'b_ndebug', 'b_vscrt'] # FIXME add lto, pgo and the like
+        self.target = target
+        self.is_64 = ('x64' in target) or ('x86_64' in target)
+        # do some canonicalization of target machine
+        if 'x86_64' in target:
+            self.machine = 'x64'
+        elif '86' in target:
+            self.machine = 'x86'
+        else:
+            self.machine = target
+
+    # Override CCompiler.get_always_args
+    def get_always_args(self):
+        return self.always_args
+
+    def get_linker_debug_crt_args(self):
+        """
+        Arguments needed to select a debug crt for the linker
+
+        Sometimes we need to manually select the CRT (C runtime) to use with
+        MSVC. One example is when trying to link with static libraries since
+        MSVC won't auto-select a CRT for us in that case and will error out
+        asking us to select one.
+        """
+        return ['/MDd']
+
+    def get_buildtype_args(self, buildtype):
+        args = msvc_buildtype_args[buildtype]
+        if self.id == 'msvc' and version_compare(self.version, '<18.0'):
+            args = [arg for arg in args if arg != '/Gw']
+        return args
+
+    def get_buildtype_linker_args(self, buildtype):
+        return msvc_buildtype_linker_args[buildtype]
+
+    def get_pch_suffix(self):
+        return 'pch'
+
+    def get_pch_name(self, header):
+        chopped = os.path.basename(header).split('.')[:-1]
+        chopped.append(self.get_pch_suffix())
+        pchname = '.'.join(chopped)
+        return pchname
+
+    def get_pch_use_args(self, pch_dir, header):
+        base = os.path.basename(header)
+        if self.id == 'clang-cl':
+            base = header
+        pchname = self.get_pch_name(header)
+        return ['/FI' + base, '/Yu' + base, '/Fp' + os.path.join(pch_dir, pchname)]
+
+    def get_preprocess_only_args(self):
+        return ['/EP']
+
+    def get_compile_only_args(self):
+        return ['/c']
+
+    def get_no_optimization_args(self):
+        return ['/Od']
+
+    def get_output_args(self, target):
+        if target.endswith('.exe'):
+            return ['/Fe' + target]
+        return ['/Fo' + target]
+
+    def get_optimization_args(self, optimization_level):
+        return msvc_optimization_args[optimization_level]
+
+    def get_debug_args(self, is_debug):
+        return msvc_debug_args[is_debug]
+
+    def get_dependency_gen_args(self, outtarget, outfile):
+        return []
+
+    def get_linker_exelist(self):
+        # FIXME, should have same path as compiler.
+        # FIXME, should be controllable via cross-file.
+        if self.id == 'clang-cl':
+            return ['lld-link']
+        else:
+            return ['link']
+
+    def get_linker_always_args(self):
+        return ['/nologo']
+
+    def get_linker_output_args(self, outputname):
+        return ['/MACHINE:' + self.machine, '/OUT:' + outputname]
+
+    def get_linker_search_args(self, dirname):
+        return ['/LIBPATH:' + dirname]
+
+    def linker_to_compiler_args(self, args):
+        return ['/link'] + args
+
+    def get_gui_app_args(self, value):
+        # the default is for the linker to guess the subsystem based on presence
+        # of main or WinMain symbols, so always be explicit
+        if value:
+            return ['/SUBSYSTEM:WINDOWS']
+        else:
+            return ['/SUBSYSTEM:CONSOLE']
+
+    def get_pic_args(self):
+        return [] # PIC is handled by the loader on Windows
+
+    def gen_export_dynamic_link_args(self, env):
+        return [] # Not applicable with MSVC
+
+    def get_std_shared_lib_link_args(self):
+        return ['/DLL']
+
+    def gen_vs_module_defs_args(self, defsfile):
+        if not isinstance(defsfile, str):
+            raise RuntimeError('Module definitions file should be str')
+        # With MSVC, DLLs only export symbols that are explicitly exported,
+        # so if a module defs file is specified, we use that to export symbols
+        return ['/DEF:' + defsfile]
+
+    def gen_pch_args(self, header, source, pchname):
+        objname = os.path.splitext(pchname)[0] + '.obj'
+        return objname, ['/Yc' + header, '/Fp' + pchname, '/Fo' + objname]
+
+    def gen_import_library_args(self, implibname):
+        "The name of the outputted import library"
+        return ['/IMPLIB:' + implibname]
+
+    def build_rpath_args(self, build_dir, from_dir, rpath_paths, build_rpath, install_rpath):
+        return []
+
+    def openmp_flags(self):
+        return ['/openmp']
+
+    # FIXME, no idea what these should be.
+    def thread_flags(self, env):
+        return []
+
+    def thread_link_flags(self, env):
+        return []
+
+    @classmethod
+    def unix_args_to_native(cls, args):
+        result = []
+        for i in args:
+            # -mms-bitfields is specific to MinGW-GCC
+            # -pthread is only valid for GCC
+            if i in ('-mms-bitfields', '-pthread'):
+                continue
+            if i.startswith('-L'):
+                i = '/LIBPATH:' + i[2:]
+            # Translate GNU-style -lfoo library name to the import library
+            elif i.startswith('-l'):
+                name = i[2:]
+                if name in cls.ignore_libs:
+                    # With MSVC, these are provided by the C runtime which is
+                    # linked in by default
+                    continue
+                else:
+                    i = name + '.lib'
+            # -pthread in link flags is only used on Linux
+            elif i == '-pthread':
+                continue
+            result.append(i)
+        return result
+
+    def get_werror_args(self):
+        return ['/WX']
+
+    def get_include_args(self, path, is_system):
+        if path == '':
+            path = '.'
+        # msvc does not have a concept of system header dirs.
+        return ['-I' + path]
+
+    def compute_parameters_with_absolute_paths(self, parameter_list, build_dir):
+        for idx, i in enumerate(parameter_list):
+            if i[:2] == '-I' or i[:2] == '/I':
+                parameter_list[idx] = i[:2] + os.path.normpath(os.path.join(build_dir, i[2:]))
+            elif i[:9] == '/LIBPATH:':
+                parameter_list[idx] = i[:9] + os.path.normpath(os.path.join(build_dir, i[9:]))
+
+        return parameter_list
+
+    # Visual Studio is special. It ignores some arguments it does not
+    # understand and you can't tell it to error out on those.
+    # http://stackoverflow.com/questions/15259720/how-can-i-make-the-microsoft-c-compiler-treat-unknown-flags-as-errors-rather-t
+    def has_arguments(self, args, env, code, mode):
+        warning_text = '4044' if mode == 'link' else '9002'
+        if self.id == 'clang-cl' and mode != 'link':
+            args = args + ['-Werror=unknown-argument']
+        with self._build_wrapper(code, env, extra_args=args, mode=mode) as p:
+            if p.returncode != 0:
+                return False, p.cached
+            return not(warning_text in p.stde or warning_text in p.stdo), p.cached
+
+    def get_compile_debugfile_args(self, rel_obj, pch=False):
+        pdbarr = rel_obj.split('.')[:-1]
+        pdbarr += ['pdb']
+        args = ['/Fd' + '.'.join(pdbarr)]
+        # When generating a PDB file with PCH, all compile commands write
+        # to the same PDB file. Hence, we need to serialize the PDB
+        # writes using /FS since we do parallel builds. This slows down the
+        # build obviously, which is why we only do this when PCH is on.
+        # This was added in Visual Studio 2013 (MSVC 18.0). Before that it was
+        # always on: https://msdn.microsoft.com/en-us/library/dn502518.aspx
+        if pch and self.id == 'msvc' and version_compare(self.version, '>=18.0'):
+            args = ['/FS'] + args
+        return args
+
+    def get_link_debugfile_args(self, targetfile):
+        pdbarr = targetfile.split('.')[:-1]
+        pdbarr += ['pdb']
+        return ['/DEBUG', '/PDB:' + '.'.join(pdbarr)]
+
+    def get_link_whole_for(self, args):
+        # Only since VS2015
+        args = mesonlib.listify(args)
+        return ['/WHOLEARCHIVE:' + x for x in args]
+
+    def get_instruction_set_args(self, instruction_set):
+        if self.is_64:
+            return vs64_instruction_set_args.get(instruction_set, None)
+        if self.id == 'msvc' and self.version.split('.')[0] == '16' and instruction_set == 'avx':
+            # VS documentation says that this exists and should work, but
+            # it does not. The headers do not contain AVX intrinsics
+            # and the can not be called.
+            return None
+        return vs32_instruction_set_args.get(instruction_set, None)
+
+    def get_toolset_version(self):
+        if self.id == 'clang-cl':
+            # I have no idea
+            return '14.1'
+
+        # See boost/config/compiler/visualc.cpp for up to date mapping
+        try:
+            version = int(''.join(self.version.split('.')[0:2]))
+        except ValueError:
+            return None
+        if version < 1310:
+            return '7.0'
+        elif version < 1400:
+            return '7.1' # (Visual Studio 2003)
+        elif version < 1500:
+            return '8.0' # (Visual Studio 2005)
+        elif version < 1600:
+            return '9.0' # (Visual Studio 2008)
+        elif version < 1700:
+            return '10.0' # (Visual Studio 2010)
+        elif version < 1800:
+            return '11.0' # (Visual Studio 2012)
+        elif version < 1900:
+            return '12.0' # (Visual Studio 2013)
+        elif version < 1910:
+            return '14.0' # (Visual Studio 2015)
+        elif version < 1920:
+            return '14.1' # (Visual Studio 2017)
+        elif version < 1930:
+            return '14.2' # (Visual Studio 2019)
+        mlog.warning('Could not find toolset for version {!r}'.format(self.version))
+        return None
+
+    def get_default_include_dirs(self):
+        if 'INCLUDE' not in os.environ:
+            return []
+        return os.environ['INCLUDE'].split(os.pathsep)
+
+    def get_crt_compile_args(self, crt_val, buildtype):
+        if crt_val in self.crt_args:
+            return self.crt_args[crt_val]
+        assert(crt_val == 'from_buildtype')
+        # Match what build type flags used to do.
+        if buildtype == 'plain':
+            return []
+        elif buildtype == 'debug':
+            return self.crt_args['mdd']
+        elif buildtype == 'debugoptimized':
+            return self.crt_args['md']
+        elif buildtype == 'release':
+            return self.crt_args['md']
+        elif buildtype == 'minsize':
+            return self.crt_args['md']
+        else:
+            assert(buildtype == 'custom')
+            raise mesonlib.EnvironmentException('Requested C runtime based on buildtype, but buildtype is "custom".')
+
+    def has_func_attribute(self, name, env):
+        # MSVC doesn't have __attribute__ like Clang and GCC do, so just return
+        # false without compiling anything
+        return name in ['dllimport', 'dllexport'], False
+
+    def get_argument_syntax(self):
+        return 'msvc'
+
+    def get_allow_undefined_link_args(self):
+        # link.exe
+        return ['/FORCE:UNRESOLVED']
+
+
 class GnuLikeCompiler(abc.ABC):
     """
     GnuLikeCompiler is a common interface to all compilers implementing

mesonbuild/compilers/cpp.py

@@ -14,12 +14,12 @@
 
 import functools
 import os.path
+import typing
 
 from .. import coredata
 from .. import mlog
 from ..mesonlib import MesonException, version_compare
 
-from .c import CCompiler, VisualStudioCCompiler, ClangClCCompiler
 from .compilers import (
     gnu_winlibs,
     msvc_winlibs,
@@ -31,20 +31,27 @@ from .compilers import (
     ArmCompiler,
     ArmclangCompiler,
     CcrxCompiler,
+    Compiler,
+    VisualStudioLikeCompiler,
 )
-from .c_function_attributes import CXX_FUNC_ATTRIBUTES
+from .c_function_attributes import CXX_FUNC_ATTRIBUTES, C_FUNC_ATTRIBUTES
+from .clike import CLikeCompiler
 
-class CPPCompiler(CCompiler):
+class CPPCompiler(CLikeCompiler, Compiler):
 
     @classmethod
     def attribute_check_func(cls, name):
-        return CXX_FUNC_ATTRIBUTES.get(name, super().attribute_check_func(name))
+        try:
+            return CXX_FUNC_ATTRIBUTES.get(name, C_FUNC_ATTRIBUTES[name])
+        except KeyError:
+            raise MesonException('Unknown function attribute "{}"'.format(name))
 
-    def __init__(self, exelist, version, is_cross, exe_wrap, **kwargs):
+    def __init__(self, exelist, version, is_cross: bool,
+                 exe_wrap: typing.Optional[str] = None, **kwargs):
         # If a child ObjCPP class has already set it, don't set it ourselves
-        if not hasattr(self, 'language'):
-            self.language = 'cpp'
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs)
+        self.language = 'cpp'
+        Compiler.__init__(self, exelist, version, **kwargs)
+        CLikeCompiler.__init__(self, is_cross, exe_wrap)
 
     def get_display_language(self):
         return 'C++'
@@ -322,25 +329,14 @@ class IntelCPPCompiler(IntelCompiler, CPPCompiler):
         return []
 
 
-class VisualStudioCPPCompiler(VisualStudioCCompiler, CPPCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap, target):
-        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
-        VisualStudioCCompiler.__init__(self, exelist, version, is_cross, exe_wrap, target)
-        self.base_options = ['b_pch', 'b_vscrt'] # FIXME add lto, pgo and the like
+class VisualStudioLikeCPPCompilerMixin:
 
-    def get_options(self):
-        cpp_stds = ['none', 'c++11', 'vc++11']
-        if self.id == 'clang-cl':
-            cpp_stds.extend(['c++14', 'vc++14', 'c++17', 'vc++17', 'c++latest'])
-        else:
-            # Visual Studio 2015 and later
-            if version_compare(self.version, '>=19'):
-                cpp_stds.extend(['c++14', 'vc++14', 'c++latest', 'vc++latest'])
-            # Visual Studio 2017 and later
-            if version_compare(self.version, '>=19.11'):
-                cpp_stds.extend(['c++17', 'vc++17'])
+    """Mixin for C++ specific method overrides in MSVC-like compilers."""
 
-        opts = CPPCompiler.get_options(self)
+    def get_option_link_args(self, options):
+        return options['cpp_winlibs'].value[:]
+
+    def _get_options_impl(self, opts, cpp_stds: typing.List[str]):
         opts.update({'cpp_eh': coredata.UserComboOption('cpp_eh',
                                                         'C++ exception handling type.',
                                                         ['none', 'a', 's', 'sc'],
@@ -393,19 +389,40 @@ class VisualStudioCPPCompiler(VisualStudioCCompiler, CPPCompiler):
 
         return args
 
-    def get_option_link_args(self, options):
-        return options['cpp_winlibs'].value[:]
-
     def get_compiler_check_args(self):
-        # Visual Studio C++ compiler doesn't support -fpermissive,
-        # so just use the plain C args.
-        return VisualStudioCCompiler.get_compiler_check_args(self)
+        # XXX: this is a hack because so much GnuLike stuff is in the base CPPCompiler class.
+        return CLikeCompiler.get_compiler_check_args(self)
 
-class ClangClCPPCompiler(VisualStudioCPPCompiler, ClangClCCompiler):
+
+class VisualStudioCPPCompiler(VisualStudioLikeCPPCompilerMixin, VisualStudioLikeCompiler, CPPCompiler):
     def __init__(self, exelist, version, is_cross, exe_wrap, target):
-        VisualStudioCPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, target)
+        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        VisualStudioLikeCompiler.__init__(self, target)
+        self.base_options = ['b_pch', 'b_vscrt'] # FIXME add lto, pgo and the like
+        self.id = 'msvc'
+
+    def get_options(self):
+        cpp_stds = ['none', 'c++11', 'vc++11']
+        # Visual Studio 2015 and later
+        if version_compare(self.version, '>=19'):
+            cpp_stds.extend(['c++14', 'vc++14', 'c++latest', 'vc++latest'])
+        # Visual Studio 2017 and later
+        if version_compare(self.version, '>=19.11'):
+            cpp_stds.extend(['c++17', 'vc++17'])
+        return self._get_options_impl(super().get_options(), cpp_stds)
+
+
+class ClangClCPPCompiler(VisualStudioLikeCPPCompilerMixin, VisualStudioLikeCompiler, CPPCompiler):
+    def __init__(self, exelist, version, is_cross, exe_wrap, target):
+        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        VisualStudioLikeCompiler.__init__(self, target)
         self.id = 'clang-cl'
 
+    def get_options(self):
+        cpp_stds = ['none', 'c++11', 'vc++11', 'c++14', 'vc++14', 'c++17', 'vc++17', 'c++latest']
+        return self._get_options_impl(super().get_options(), cpp_stds)
+
+
 class ArmCPPCompiler(ArmCompiler, CPPCompiler):
     def __init__(self, exelist, version, compiler_type, is_cross, exe_wrap=None, **kwargs):
         CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap, **kwargs)

mesonbuild/compilers/fortran.py

@@ -15,7 +15,6 @@ from typing import List
 import subprocess, os
 from pathlib import Path
 
-from .c import CCompiler
 from .compilers import (
     CompilerType,
     apple_buildtype_linker_args,
@@ -28,54 +27,26 @@ from .compilers import (
     ClangCompiler,
     ElbrusCompiler,
     IntelCompiler,
-    PGICompiler
+    PGICompiler,
 )
+from .clike import CLikeCompiler
 
 from mesonbuild.mesonlib import (
     EnvironmentException, MachineChoice, is_osx, LibType
 )
 
 
-class FortranCompiler(Compiler):
-    library_dirs_cache = CCompiler.library_dirs_cache
-    program_dirs_cache = CCompiler.library_dirs_cache
-    find_library_cache = CCompiler.library_dirs_cache
+class FortranCompiler(CLikeCompiler, Compiler):
 
     def __init__(self, exelist, version, is_cross, exe_wrapper=None, **kwargs):
         self.language = 'fortran'
         Compiler.__init__(self, exelist, version, **kwargs)
-        cc = CCompiler(exelist, version, is_cross, exe_wrapper, **kwargs)
+        CLikeCompiler.__init__(self, is_cross, exe_wrapper)
         self.id = 'unknown'
-        self.is_cross = cc.is_cross
-        self.exe_wrapper = cc.exe_wrapper
 
     def get_display_language(self):
         return 'Fortran'
 
-    def needs_static_linker(self):
-        return CCompiler.needs_static_linker(self)
-
-    def get_always_args(self):
-        return CCompiler.get_always_args(self)
-
-    def get_linker_debug_crt_args(self):
-        return CCompiler.get_linker_debug_crt_args(self)
-
-    def get_no_stdinc_args(self):
-        return CCompiler.get_no_stdinc_args(self)
-
-    def get_no_stdlib_link_args(self):
-        return CCompiler.get_no_stdlib_link_args(self)
-
-    def get_warn_args(self, level):
-        return CCompiler.get_warn_args(self, level)
-
-    def get_no_warn_args(self):
-        return CCompiler.get_no_warn_args(self)
-
-    def get_soname_args(self, *args):
-        return CCompiler.get_soname_args(self, *args)
-
     def sanity_check(self, work_dir: Path, environment):
         """
         Check to be sure a minimal program can compile and execute
@@ -133,59 +104,11 @@ class FortranCompiler(Compiler):
             return apple_buildtype_linker_args[buildtype]
         return gnulike_buildtype_linker_args[buildtype]
 
-    def split_shlib_to_parts(self, fname):
-        return CCompiler.split_shlib_to_parts(self, fname)
-
-    def build_rpath_args(self, *args):
-        return CCompiler.build_rpath_args(self, *args)
-
     def get_dependency_gen_args(self, outtarget, outfile):
         return []
 
-    def depfile_for_object(self, objfile):
-        return CCompiler.depfile_for_object(self, objfile)
-
-    def get_depfile_suffix(self):
-        return CCompiler.get_depfile_suffix(self)
-
-    def get_exelist(self):
-        return CCompiler.get_exelist(self)
-
-    def get_linker_exelist(self):
-        return CCompiler.get_linker_exelist(self)
-
     def get_preprocess_only_args(self):
-        return ['-cpp'] + CCompiler.get_preprocess_only_args(self)
-
-    def get_compile_only_args(self):
-        return CCompiler.get_compile_only_args(self)
-
-    def get_no_optimization_args(self):
-        return CCompiler.get_no_optimization_args(self)
-
-    def get_compiler_check_args(self):
-        return CCompiler.get_compiler_check_args(self)
-
-    def get_output_args(self, target):
-        return CCompiler.get_output_args(self, target)
-
-    def get_linker_output_args(self, outputname):
-        return CCompiler.get_linker_output_args(self, outputname)
-
-    def get_coverage_args(self):
-        return CCompiler.get_coverage_args(self)
-
-    def get_coverage_link_args(self):
-        return CCompiler.get_coverage_link_args(self)
-
-    def get_werror_args(self):
-        return CCompiler.get_werror_args(self)
-
-    def get_std_exe_link_args(self):
-        return CCompiler.get_std_exe_link_args(self)
-
-    def get_include_args(self, path, is_system):
-        return CCompiler.get_include_args(self, path, is_system)
+        return ['-cpp'] + super().get_preprocess_only_args()
 
     def get_module_incdir_args(self):
         return ('-I', )
@@ -214,102 +137,12 @@ class FortranCompiler(Compiler):
 
         return filename
 
-    def get_std_shared_lib_link_args(self):
-        return CCompiler.get_std_shared_lib_link_args(self)
-
-    def _get_search_dirs(self, *args, **kwargs):
-        return CCompiler._get_search_dirs(self, *args, **kwargs)
-
-    def get_compiler_dirs(self, *args, **kwargs):
-        return CCompiler.get_compiler_dirs(self, *args, **kwargs)
-
-    def get_library_dirs(self, *args, **kwargs):
-        return CCompiler.get_library_dirs(self, *args, **kwargs)
-
-    def get_pic_args(self):
-        return CCompiler.get_pic_args(self)
-
-    def name_string(self):
-        return CCompiler.name_string(self)
-
-    def get_linker_search_args(self, dirname):
-        return CCompiler.get_linker_search_args(self, dirname)
-
-    def get_default_include_dirs(self):
-        return CCompiler.get_default_include_dirs(self)
-
-    def gen_export_dynamic_link_args(self, env):
-        return CCompiler.gen_export_dynamic_link_args(self, env)
-
-    def gen_import_library_args(self, implibname):
-        return CCompiler.gen_import_library_args(self, implibname)
-
-    def _get_basic_compiler_args(self, env, mode):
-        return CCompiler._get_basic_compiler_args(self, env, mode)
-
-    def _get_compiler_check_args(self, env, extra_args, dependencies, mode='compile'):
-        return CCompiler._get_compiler_check_args(self, env, extra_args, dependencies, mode=mode)
-
-    def compiles(self, code, env, *, extra_args=None, dependencies=None, mode='compile', disable_cache=False):
-        return CCompiler.compiles(self, code, env, extra_args=extra_args,
-                                  dependencies=dependencies, mode=mode, disable_cache=disable_cache)
-
-    def _build_wrapper(self, code, env, extra_args, dependencies=None, mode='compile', want_output=False, disable_cache=False):
-        return CCompiler._build_wrapper(self, code, env, extra_args, dependencies, mode, want_output, disable_cache=disable_cache)
-
-    def links(self, code, env, *, extra_args=None, dependencies=None, disable_cache=False):
-        return CCompiler.links(self, code, env, extra_args=extra_args,
-                               dependencies=dependencies, disable_cache=disable_cache)
-
-    def run(self, code, env, *, extra_args=None, dependencies=None):
-        return CCompiler.run(self, code, env, extra_args=extra_args, dependencies=dependencies)
-
-    def _get_patterns(self, *args, **kwargs):
-        return CCompiler._get_patterns(self, *args, **kwargs)
-
-    def get_library_naming(self, *args, **kwargs):
-        return CCompiler.get_library_naming(self, *args, **kwargs)
-
-    def find_library_real(self, *args):
-        return CCompiler.find_library_real(self, *args)
-
-    def find_library_impl(self, *args):
-        return CCompiler.find_library_impl(self, *args)
-
     def find_library(self, libname, env, extra_dirs, libtype: LibType = LibType.PREFER_SHARED):
         code = '''program main
             call exit(0)
         end program main'''
         return self.find_library_impl(libname, env, extra_dirs, code, libtype)
 
-    def thread_flags(self, env):
-        return CCompiler.thread_flags(self, env)
-
-    def thread_link_flags(self, env):
-        return CCompiler.thread_link_flags(self, env)
-
-    def linker_to_compiler_args(self, args):
-        return CCompiler.linker_to_compiler_args(self, args)
-
-    def has_arguments(self, args, env, code, mode):
-        return CCompiler.has_arguments(self, args, env, code, mode)
-
-    def has_multi_arguments(self, args, env):
-        return CCompiler.has_multi_arguments(self, args, env)
-
-    def has_header(self, hname, prefix, env, *, extra_args=None, dependencies=None, disable_cache=False):
-        return CCompiler.has_header(self, hname, prefix, env, extra_args=extra_args, dependencies=dependencies, disable_cache=disable_cache)
-
-    def get_define(self, dname, prefix, env, extra_args, dependencies, disable_cache=False):
-        return CCompiler.get_define(self, dname, prefix, env, extra_args, dependencies, disable_cache=disable_cache)
-
-    @classmethod
-    def _get_trials_from_pattern(cls, pattern, directory, libname):
-        return CCompiler._get_trials_from_pattern(pattern, directory, libname)
-
-    @staticmethod
-    def _get_file_from_list(env, files: List[str]) -> Path:
-        return CCompiler._get_file_from_list(env, files)
 
 class GnuFortranCompiler(GnuCompiler, FortranCompiler):
     def __init__(self, exelist, version, compiler_type, is_cross, exe_wrapper=None, defines=None, **kwargs):

mesonbuild/compilers/objc.py

@@ -13,16 +13,18 @@
 # limitations under the License.
 
 import os.path, subprocess
+import typing
 
 from ..mesonlib import EnvironmentException, MachineChoice
 
-from .c import CCompiler
-from .compilers import ClangCompiler, GnuCompiler
+from .clike import CLikeCompiler
+from .compilers import Compiler, ClangCompiler, GnuCompiler
 
-class ObjCCompiler(CCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap):
+class ObjCCompiler(CLikeCompiler, Compiler):
+    def __init__(self, exelist, version, is_cross: bool, exe_wrap: typing.Optional[str]):
         self.language = 'objc'
-        CCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        Compiler.__init__(self, exelist, version)
+        CLikeCompiler.__init__(self, is_cross, exe_wrap)
 
     def get_display_language(self):
         return 'Objective-C'

mesonbuild/compilers/objcpp.py

@@ -13,16 +13,18 @@
 # limitations under the License.
 
 import os.path, subprocess
+import typing
 
 from ..mesonlib import EnvironmentException, MachineChoice
 
-from .cpp import CPPCompiler
-from .compilers import ClangCompiler, GnuCompiler
+from .clike import CLikeCompiler
+from .compilers import Compiler, ClangCompiler, GnuCompiler
 
-class ObjCPPCompiler(CPPCompiler):
-    def __init__(self, exelist, version, is_cross, exe_wrap):
+class ObjCPPCompiler(CLikeCompiler, Compiler):
+    def __init__(self, exelist, version, is_cross: bool, exe_wrap: typing.Optional[str]):
         self.language = 'objcpp'
-        CPPCompiler.__init__(self, exelist, version, is_cross, exe_wrap)
+        Compiler.__init__(self, exelist, version)
+        CLikeCompiler.__init__(self, is_cross, exe_wrap)
 
     def get_display_language(self):
         return 'Objective-C++'

mesonbuild/environment.py

@@ -1158,7 +1158,7 @@ class Environment:
                 linkers = [self.cuda_static_linker, self.default_static_linker]
             elif evar in os.environ:
                 linkers = [shlex.split(os.environ[evar])]
-            elif isinstance(compiler, compilers.VisualStudioCCompiler):
+            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

run_unittests.py

@@ -1939,8 +1939,8 @@ class AllPlatformTests(BasePlatformTests):
         gnu = mesonbuild.compilers.GnuCompiler
         clang = mesonbuild.compilers.ClangCompiler
         intel = mesonbuild.compilers.IntelCompiler
-        msvc = mesonbuild.compilers.VisualStudioCCompiler
-        clangcl = mesonbuild.compilers.ClangClCCompiler
+        msvc = (mesonbuild.compilers.VisualStudioCCompiler, mesonbuild.compilers.VisualStudioCPPCompiler)
+        clangcl = (mesonbuild.compilers.ClangClCCompiler, mesonbuild.compilers.ClangClCPPCompiler)
         ar = mesonbuild.linkers.ArLinker
         lib = mesonbuild.linkers.VisualStudioLinker
         langs = [('c', 'CC'), ('cpp', 'CXX')]