Add static analysis support to Win Clang builds

build/toolchain/clang_static_analyzer_wrapper.py

Index: build/toolchain/clang_static_analyzer_wrapper.py
diff --git a/build/toolchain/clang_static_analyzer_wrapper.py b/build/toolchain/clang_static_analyzer_wrapper.py
index 3a282ad48d5ae13feabc376a0525ed7f27419289..2a1ef16dee2710ac0eb1ff9dc0840a0ad6a2cca8 100755
--- a/build/toolchain/clang_static_analyzer_wrapper.py
+++ b/build/toolchain/clang_static_analyzer_wrapper.py
@@ -18,11 +18,11 @@ import wrapper_utils
 # Flags used to enable analysis for Clang invocations.
 analyzer_enable_flags = [
     '--analyze',
-    '-fdiagnostics-show-option',
 ]
 
 # Flags used to configure the analyzer's behavior.
 analyzer_option_flags = [
+    '-fdiagnostics-show-option',
     '-analyzer-checker=cplusplus',
     '-analyzer-opt-analyze-nested-blocks',
     '-analyzer-eagerly-assume',
@@ -39,37 +39,39 @@ analyzer_option_flags = [
 ]
 
 
-def main():
-  args = sys.argv[1:]
-  assert args
+# Prepends every element of a list |args| with |token|.
+# e.g. ['-analyzer-foo', '-analyzer-bar'] => ['-Xanalyzer', '-analyzer-foo',
+#                                             '-Xanalyzer', '-analyzer-bar']
+def interleave_args(args, token):
+  return list(sum(zip([token] * len(args), args), ()))
 
-  # Build the object file and proceed with analysis if it is buildable.
-  returncode, stderr = wrapper_utils.CaptureCommandStderr(
-    wrapper_utils.CommandToRun(args))
-  sys.stderr.write(stderr)
-  if returncode != 0:
-    return returncode
 
-  # Now run the analyzer.
+def main():
+  parser = argparse.ArgumentParser()
+  parser.add_argument('--cl-mode',
+                      help='Uses compiler arguments compatible with clang-cl.',
+                      action='store_true')

[brucedawson, 2017/03/14 17:56:38]

I'm not familiar enough with the available options, but would it be obvious to
an expert what happens when cl-mode is not specified? i.e.; is it obvious that
!--cl-mode means Xanalyzer?

In other words, would it be better to have --analyze-mode=[Xanalyzer|Xclang], or
is the current flag sufficient? Just checking.

[Kevin M, 2017/03/14 19:11:03]

My thinking was that the layperson would assume that the omission of an optional
parameter would result in default behavior. That's strictly true in this case,
as -Xanalyzer is the native Clang interface for passing analyzer arguments --
clang_cl.exe is an adapter layer, so in my view it represents an alternate mode.

I can see how the layperson wouldn't care about that technical distinction, so
I'll just expose the two choices as an explicit string option. I think exposing
the detail of the exact arg prefix may be too esoteric, so I'll abstract the
choice as "clang" and "cl" instead.

+  parser.add_argument('args', nargs=argparse.REMAINDER)
+  parsed_args = parser.parse_args()
 
-  # Interleave 'analyzer_option_flags' flags w/'-Xanalyzer' so that Clang
-  # passes them to the analysis tool.
-  # e.g. ['-analyzer-foo', '-analyzer-bar'] => ['-Xanalyzer', '-analyzer-foo',
-  #                                             '-Xanalyzer', '-analyzer-bar']
-  interleaved_analyzer_flags = list(sum(zip(
-      ['-Xanalyzer'] * len(analyzer_option_flags),
-      analyzer_option_flags), ()))
+  # Run the analyzer.
+  prefix = '-Xclang' if parsed_args.cl_mode else '-Xanalyzer'
+  cmd = parsed_args.args + analyzer_enable_flags + \
+        interleave_args(analyzer_option_flags, prefix)
   returncode, stderr = wrapper_utils.CaptureCommandStderr(
-      wrapper_utils.CommandToRun(args + analyzer_enable_flags +
-                                 interleaved_analyzer_flags))
+      wrapper_utils.CommandToRun(cmd))
   sys.stderr.write(stderr)
   if returncode != 0:
     sys.stderr.write(
         """WARNING! The Clang static analyzer exited with error code %d.
          Please share the error details in crbug.com/695243 if this looks like
          a new regression.\n""" % (returncode))
+    sys.stderr.write('Falling back to standard build without analysis...\n');
+    returncode, stderr = wrapper_utils.CaptureCommandStderr(
+      wrapper_utils.CommandToRun(parsed_args.args))
+    sys.stderr.write(stderr)
 
-  return 0
+  return returncode
 
 if __name__ == '__main__':
   sys.exit(main())