[analyzer] [tests] Allow specifying entire -analyze-config on the command line, make sure it's always propagated

[NoQ]

Nice!

clang/utils/analyzer/SATestBuild.py

def runScanBuild(Args, Dir, SBOutputDir, PBuildLogFile):
 
     # Run scan-build from within the patched source directory.
     SBCwd = os.path.join(Dir, PatchedSourceDirName)
 
     SBOptions = "--use-analyzer '%s' " % Clang
     SBOptions += "-plist-html -o '%s' " % SBOutputDir
     SBOptions += "-enable-checker " + AllCheckers + " "
     SBOptions += "--keep-empty "
-    AnalyzerConfig = [
-        ("stable-report-filename", "true"),
-        ("serialize-stats", "true"),
-    ]
-    AnalyzerConfigSerialized = ",".join(
-        "%s=%s" % (key, value) for (key, value) in AnalyzerConfig)
-    if Args.extra_args:
-        AnalyzerConfigSerialized += "," + Args.extra_args
-    SBOptions += "-analyzer-config '%s' " % AnalyzerConfigSerialized
+    SBOptions += "-analyzer-config '%s' " % Args.analyzer_config
 
     # Always use ccc-analyze to ensure that we can locate the failures
     # directory.
     SBOptions += "--override-compiler "
     ExtraEnv = {}
     try:
         SBCommandFile = open(BuildScriptPath, "r")
         SBPrefix = "scan-build " + SBOptions + " "
         for Command in SBCommandFile:
             Command = Command.strip()
             if len(Command) == 0:
                 continue
 
             # Custom analyzer invocation specified by project.
             # Communicate required information using environment variables
             # instead.
             if Command == NoPrefixCmd:
                 SBPrefix = ""
                 ExtraEnv['OUTPUT'] = SBOutputDir
                 ExtraEnv['CC'] = Clang
+                ExtraEnv['ANALYZER_CONFIG'] = Args.analyzer_config
                 continue
 
             # If using 'make', auto imply a -jX argument
             # to speed up analysis.  xcodebuild will
             # automatically use the maximum number of cores.
             if (Command.startswith("make ") or Command == "make") and \
                     "-j" not in Command:
                 Command += " -j%d" % MaxJobs
             SBCommand = SBPrefix + Command
 
             if Verbose == 1:
                 Local.stdout.write("  Executing: %s\n" % (SBCommand,))
             check_call(SBCommand, cwd=SBCwd,
                        stderr=PBuildLogFile,
                        stdout=PBuildLogFile,
                        env=dict(os.environ, **ExtraEnv),
                        shell=True)
     except CalledProcessError:
         Local.stderr.write("Error: scan-build failed. Its output was: \n")
         PBuildLogFile.seek(0)
         shutil.copyfileobj(PBuildLogFile, Local.stderr)
         sys.exit(1)
 
 
-def runAnalyzePreprocessed(Dir, SBOutputDir, Mode):
+def runAnalyzePreprocessed(Args, Dir, SBOutputDir, Mode):
     """
     Run analysis on a set of preprocessed files.
     """
     if os.path.exists(os.path.join(Dir, BuildScript)):
         Local.stderr.write(
             "Error: The preprocessed files project should not contain %s\n" % (
                 BuildScript))
         raise Exception()
 
     CmdPrefix = Clang + " -cc1 "
 
     # For now, we assume the preprocessed files should be analyzed
     # with the OS X SDK.
     SDKPath = SATestUtils.getSDKPath("macosx")
     if SDKPath is not None:
         CmdPrefix += "-isysroot " + SDKPath + " "
 
     CmdPrefix += "-analyze -analyzer-output=plist -w "
     CmdPrefix += "-analyzer-checker=" + Checkers
     CmdPrefix += " -fcxx-exceptions -fblocks "
+    CmdPrefix += " -analyzer-config " + Args.analyzer_config
 
     if (Mode == 2):
         CmdPrefix += "-std=c++11 "
 
     PlistPath = os.path.join(Dir, SBOutputDir, "date")
     FailPath = os.path.join(PlistPath, "failures")
     os.makedirs(FailPath)
 
def buildProject(Args, Dir, SBOutputDir, ProjectBuildMode, IsReferenceBuild):
 
     # Build and analyze the project.
     with open(BuildLogPath, "wb+") as PBuildLogFile:
         if (ProjectBuildMode == 1):
             downloadAndPatch(Dir, PBuildLogFile)
             runCleanupScript(Dir, PBuildLogFile)
             runScanBuild(Args, Dir, SBOutputDir, PBuildLogFile)
         else:
-            runAnalyzePreprocessed(Dir, SBOutputDir, ProjectBuildMode)
+            runAnalyzePreprocessed(Args, Dir, SBOutputDir, ProjectBuildMode)
 
         if IsReferenceBuild:
             runCleanupScript(Dir, PBuildLogFile)
             normalizeReferenceResults(Dir, SBOutputDir, ProjectBuildMode)
 
     Local.stdout.write("Build complete (time: %.2f). "
                        "See the log for more details: %s\n" % (
                            (time.time() - TBegin), BuildLogPath))
Parser.add_argument('--strictness', dest='strictness', type=int, default=0,
                              number of found bugs are different from the \
                              reference, 2 to fail on any difference from the \
                              reference. Default is 0.')
     Parser.add_argument('-r', dest='regenerate', action='store_true',
                         default=False, help='Regenerate reference output.')
     Parser.add_argument('-j', '--jobs', dest='jobs', type=int,
                         default=0,
                         help='Number of projects to test concurrently')
-    Parser.add_argument('--extra-analyzer-args', dest='extra_args',
-                        type=str, default="",
-                        help="Extra arguments to add to -analyzer-config")
+    Parser.add_argument('--analyzer-config', dest='analyzer_config',
+                        type=str,
+                        default="serialize-stats=true,stable-report-filename=true",
+                        help="Arguments passed to to -analyzer-config")
     Args = Parser.parse_args()
 
     TestsPassed = testAll(Args)
     if not TestsPassed:
         print "ERROR: Tests failed."
         sys.exit(42)