Merge pull request #8773 from dcbaker/submit/rustc-enhancements-clippy

More enhancements for Rust + clippy support

3 files changed, 65 insertions, 10 deletions

diff --git a/mesonbuild/compilers/__init__.py b/mesonbuild/compilers/__init__.py
index 8c5275c..98b0b5f 100644
--- a/mesonbuild/compilers/__init__.py
+++ b/mesonbuild/compilers/__init__.py
@@ -112,6 +112,7 @@ __all__ = [
     'PGICPPCompiler',
     'PGIFortranCompiler',
     'RustCompiler',
+    'ClippyRustCompiler',
     'CcrxCCompiler',
     'CcrxCPPCompiler',
     'Xc16CCompiler',
@@ -241,7 +242,7 @@ from .objcpp import (
     ClangObjCPPCompiler,
     GnuObjCPPCompiler,
 )
-from .rust import RustCompiler
+from .rust import RustCompiler, ClippyRustCompiler
 from .swift import SwiftCompiler
 from .vala import ValaCompiler
 from .mixins.visualstudio import VisualStudioLikeCompiler
diff --git a/mesonbuild/compilers/detect.py b/mesonbuild/compilers/detect.py
index 59b425b..52ad7f3 100644
--- a/mesonbuild/compilers/detect.py
+++ b/mesonbuild/compilers/detect.py
@@ -124,7 +124,7 @@ from .objcpp import (
     GnuObjCPPCompiler,
 )
 from .cython import CythonCompiler
-from .rust import RustCompiler
+from .rust import RustCompiler, ClippyRustCompiler
 from .swift import SwiftCompiler
 from .vala import ValaCompiler
 from .mixins.visualstudio import VisualStudioLikeCompiler
@@ -952,6 +952,13 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
             continue
 
         version = search_version(out)
+        cls: T.Type[RustCompiler] = RustCompiler
+
+        # Clippy is a wrapper around rustc, but it doesn't have rustc in it's
+        # output. We can otherwise treat it as rustc.
+        if 'clippy' in out:
+            out = 'rustc'
+            cls = ClippyRustCompiler
 
         if 'rustc' in out:
             # On Linux and mac rustc will invoke gcc (clang for mac
@@ -970,19 +977,21 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
                     'or use the RUST_LD environment variable, otherwise meson '
                     'will override your selection.')
 
+            compiler = compiler.copy()  # avoid mutating the original list
+
             if override is None:
                 extra_args: T.Dict[str, T.Union[str, bool]] = {}
                 always_args: T.List[str] = []
                 if is_link_exe:
-                    compiler.extend(RustCompiler.use_linker_args(cc.linker.exelist[0]))
+                    compiler.extend(cls.use_linker_args(cc.linker.exelist[0]))
                     extra_args['direct'] = True
                     extra_args['machine'] = cc.linker.machine
                 else:
-                    exelist = cc.linker.exelist.copy()
+                    exelist = cc.linker.exelist + cc.linker.get_always_args()
                     if 'ccache' in exelist[0]:
                         del exelist[0]
                     c = exelist.pop(0)
-                    compiler.extend(RustCompiler.use_linker_args(c))
+                    compiler.extend(cls.use_linker_args(c))
 
                     # Also ensure that we pass any extra arguments to the linker
                     for l in exelist:
@@ -1000,12 +1009,12 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
                                                 **extra_args) # type: ignore
             elif 'link' in override[0]:
                 linker = guess_win_linker(env,
-                    override, RustCompiler, for_machine, use_linker_prefix=False)
+                    override, cls, for_machine, use_linker_prefix=False)
                 # rustc takes linker arguments without a prefix, and
                 # inserts the correct prefix itself.
                 assert isinstance(linker, VisualStudioLikeLinkerMixin)
                 linker.direct = True
-                compiler.extend(RustCompiler.use_linker_args(linker.exelist[0]))
+                compiler.extend(cls.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.
@@ -1017,10 +1026,10 @@ def detect_rust_compiler(env: 'Environment', for_machine: MachineChoice) -> Rust
                 # 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))
+                compiler.extend(cls.use_linker_args(c))
 
-            env.coredata.add_lang_args(RustCompiler.language, RustCompiler, for_machine, env)
-            return RustCompiler(
+            env.coredata.add_lang_args(cls.language, cls, for_machine, env)
+            return cls(
                 compiler, version, for_machine, is_cross, info, exe_wrap,
                 linker=linker)
 
diff --git a/mesonbuild/compilers/rust.py b/mesonbuild/compilers/rust.py
index 2b566c8..9423b2d 100644
--- a/mesonbuild/compilers/rust.py
+++ b/mesonbuild/compilers/rust.py
@@ -45,6 +45,13 @@ class RustCompiler(Compiler):
     # rustc doesn't invoke the compiler itself, it doesn't need a LINKER_PREFIX
     language = 'rust'
 
+    _WARNING_LEVELS: T.Dict[str, T.List[str]] = {
+        '0': ['-A', 'warnings'],
+        '1': [],
+        '2': [],
+        '3': ['-W', 'warnings'],
+    }
+
     def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
                  is_cross: bool, info: 'MachineInfo',
                  exe_wrapper: T.Optional['ExternalProgram'] = None,
@@ -168,3 +175,41 @@ class RustCompiler(Compiler):
         for a in super().get_linker_always_args():
             args.extend(['-C', f'link-arg={a}'])
         return args
+
+    def get_werror_args(self) -> T.List[str]:
+        # Use -D warnings, which makes every warning not explicitly allowed an
+        # error
+        return ['-D', 'warnings']
+
+    def get_warn_args(self, level: str) -> T.List[str]:
+        # TODO: I'm not really sure what to put here, Rustc doesn't have warning
+        return self._WARNING_LEVELS[level]
+
+    def get_no_warn_args(self) -> T.List[str]:
+        return self._WARNING_LEVELS["0"]
+
+    def get_pic_args(self) -> T.List[str]:
+        # This defaults to
+        return ['-C', 'relocation-model=pic']
+
+    def get_pie_args(self) -> T.List[str]:
+        # Rustc currently has no way to toggle this, it's controlled by whether
+        # pic is on by rustc
+        return []
+
+
+class ClippyRustCompiler(RustCompiler):
+
+    """Clippy is a linter that wraps Rustc.
+
+    This just provides us a different id
+    """
+
+    def __init__(self, exelist: T.List[str], version: str, for_machine: MachineChoice,
+                 is_cross: bool, info: 'MachineInfo',
+                 exe_wrapper: T.Optional['ExternalProgram'] = None,
+                 full_version: T.Optional[str] = None,
+                 linker: T.Optional['DynamicLinker'] = None):
+        super().__init__(exelist, version, for_machine, is_cross, info,
+                         exe_wrapper, full_version, linker)
+        self.id = 'clippy-driver rustc'