[gobject-introspection/clang-cl] giscanner: Add support for using clang-cl

[Chun-wei Fan <fanchunwei src gnome org>]

commit b0ffd96e08e2cf6ab81d878696d07746ff2834ef
Author: Chun-wei Fan <fanchunwei src gnome org>
Date:   Thu Aug 20 18:07:54 2020 +0800

    giscanner: Add support for using clang-cl
    
    This adds quick support for using 'clang-cl' (CLang's emulation of the Visual
    Studio compiler) to run giscanner.
    
    This will still initialize things mostly in the MSVC fashion, except that it
    will also check whether both 'CC' and 'CXX' envvars are set to
    'clang-cl [args]', as per the way that Meson supports using 'clang-cl'.
    
    Since we are using distutils to set up the compiler instance, when we enable
    'clang-cl' support, we trick distutils that we have already initialized the
    MSVCCompiler parameters as needed.  We just leave out the compiler flags as
    we don't really care about debug symbols nor optimization with the built
    dumper binary, as it is gone as soon as the .gir file is generated.
    
    This will build G-I successfully with all the tests passed.

 giscanner/ccompiler.py    | 14 ++++++++------
 giscanner/msvccompiler.py | 22 ++++++++++++++++++++++
 2 files changed, 30 insertions(+), 6 deletions(-)
---
diff --git a/giscanner/ccompiler.py b/giscanner/ccompiler.py
index a81d4b867..bd1aa78ed 100644
--- a/giscanner/ccompiler.py
+++ b/giscanner/ccompiler.py
@@ -163,9 +163,11 @@ class CCompiler(object):
                 elif os.environ.get('VCInstallDir'):
                     os.environ['MSSdk'] = os.environ.get('VCInstallDir')
 
-            self.compiler_cmd = 'cl.exe'
-
-            self._cflags_no_deprecation_warnings = "-wd4996"
+            if self.compiler.check_is_clang_cl():
+                self.compiler_cmd = os.environ.get('CC').split()[0]
+            else:
+                self.compiler_cmd = 'cl.exe'
+                self._cflags_no_deprecation_warnings = "-wd4996"
         else:
             if (isinstance(self.compiler, Mingw32CCompiler)):
                 self.compiler_cmd = self.compiler.compiler[0]
@@ -263,7 +265,7 @@ class CCompiler(object):
         # Define these macros when using Visual C++ to silence many warnings,
         # and prevent stepping on many Visual Studio-specific items, so that
         # we don't have to handle them specifically in scannerlexer.l
-        if self.check_is_msvc():
+        if self.check_is_msvc() and not self.compiler.check_is_clang_cl():
             macros.append(('_USE_DECLSPECS_FOR_SAL', None))
             macros.append(('_CRT_SECURE_NO_WARNINGS', None))
             macros.append(('_CRT_NONSTDC_NO_WARNINGS', None))
@@ -318,7 +320,7 @@ class CCompiler(object):
         args = []
         libsearch = []
 
-        # When we are using Visual C++...
+        # When we are using Visual C++ or clang-cl...
         if self.check_is_msvc():
             # The search path of the .lib's on Visual C++
             # is dependent on the LIB environmental variable,
@@ -336,7 +338,7 @@ class CCompiler(object):
             args.append('dumpbin.exe')
             args.append('-symbols')
 
-        # When we are not using Visual C++ (i.e. we are using GCC)...
+        # When we are not using Visual C++ nor clang-cl (i.e. we are using GCC)...
         else:
             libtool = utils.get_libtool_command(options)
             if libtool:
diff --git a/giscanner/msvccompiler.py b/giscanner/msvccompiler.py
index d13eb8084..0a5439820 100644
--- a/giscanner/msvccompiler.py
+++ b/giscanner/msvccompiler.py
@@ -36,6 +36,7 @@ def get_msvc_compiler():
 class MSVCCompiler(distutils.msvccompiler.MSVCCompiler):
 
     def __init__(self, verbose=0, dry_run=0, force=0):
+        super(distutils.msvccompiler.MSVCCompiler, self).__init__()
         CCompiler.__init__(self, verbose, dry_run, force)
         self.__paths = []
         self.__arch = None  # deprecated name
@@ -44,6 +45,16 @@ class MSVCCompiler(distutils.msvccompiler.MSVCCompiler):
                 self.__version = distutils.msvc9compiler.VERSION
         self.initialized = False
         self.preprocess_options = None
+        if self.check_is_clang_cl():
+            cc_cmd = os.environ.get('CC').split()
+            self.cc = cc_cmd[0]
+            self.linker = 'lld-link'
+            self.compile_options = []
+            # Add any arguments added to clang-cl to self.compile_options
+            # such as cross-compilation flags
+            if len(cc_cmd) > 1:
+                self.compile_options.extend(cc_cmd[1:])
+            self.initialized = True
 
     def preprocess(self,
                    source,
@@ -98,3 +109,14 @@ class MSVCCompiler(distutils.msvccompiler.MSVCCompiler):
             return filename[filename.rfind('\\') + 1:]
         else:
             return filename[filename.rfind('\\') + 1:filename.rfind('.')]
+
+    def check_is_clang_cl(self):
+        # To run g-ir-scanner under Windows using clang-cl, set both `CC` and
+        # `CXX` to `clang-cl [<arch_args>]` and ensure that clang-cl.exe and
+        # lld-link.exe are in the PATH in a Visual Studio command prompt.  Note
+        # that the Windows SDK is still needed in this case.  This is in line
+        # with what is done in Meson
+        return (os.environ.get('CC') is not None and
+                os.environ.get('CXX') is not None and
+                os.environ.get('CC').split()[0] == 'clang-cl' and
+                os.environ.get('CXX').split()[0] == 'clang-cl')