[analyzer] SATest: Add option to specify projects to test

[NoQ]

clang/utils/analyzer/SATest.py

137

Typo!

[vsavchenko]

Fix typo

clang/utils/analyzer/ProjectMap.py

class ProjectInfo(NamedTuple):
     """
     name: str
     mode: int
     source: DownloadType = DownloadType.SCRIPT
     origin: str = ""
     commit: str = ""
     enabled: bool = True
 
+    def with_fields(self, **kwargs) -> "ProjectInfo":
+        """
+        Create a copy of this project info with customized fields.
+        NamedTuple is immutable and this is a way to create modified copies.
+
+          info.enabled = True
+          info.mode = 1
+
+        can be done as follows:
+
+          modified = info.with_fields(enbled=True, mode=1)
+        """
+        return ProjectInfo(**{**self._asdict(), **kwargs})
+
 
 class ProjectMap:
     """
     Project map stores info about all the "registered" projects.
     """
     def __init__(self, path: Optional[str] = None, should_exist: bool = True):
         """
         :param path: optional path to a project JSON file, when None defaults

clang/utils/analyzer/SATest.py

def add(parser, args):
     project = ProjectInfo(args.name[0], args.mode, args.source, args.origin,
                           args.commit)
 
     SATestAdd.add_new_project(project)
 
 
 def build(parser, args):
     SATestBuild.VERBOSE = args.verbose
-    tester = SATestBuild.RegressionTester(args.jobs, args.override_compiler,
+
+    project_map = ProjectMap()
+    projects = project_map.projects
+
+    if args.projects:
+        projects_arg = args.projects.split(",")
+        available_projects = [project.name
+                              for project in projects]
+
+        # validate that given projects are present in the project map file
+        for manual_project in projects_arg:
+            if manual_project not in available_projects:
+                parser.error("Project '{project}' is not found in "
+                             "the project map file. Available projects are "
+                             "{all}.".format(project=manual_project,
+                                             all=available_projects))
+
+        projects = [project.with_fields(enabled=project.name in projects_arg)
+                    for project in projects]
+
+    tester = SATestBuild.RegressionTester(args.jobs,
+                                          projects,
+                                          args.override_compiler,
                                           args.extra_analyzer_config,
                                           args.regenerate,
                                           args.strictness)
     tests_passed = tester.test_all()
 
     if not tests_passed:
         sys.stderr.write("ERROR: Tests failed.\n")
         sys.exit(42)
build_parser.add_argument("--override-compiler", action="store_true",
                               "--override-compiler option.")
     build_parser.add_argument("-j", "--jobs", dest="jobs",
                               type=int, default=0,
                               help="Number of projects to test concurrently")
     build_parser.add_argument("--extra-analyzer-config",
                               dest="extra_analyzer_config", type=str,
                               default="",
                               help="Arguments passed to to -analyzer-config")
+    build_parser.add_argument("--projects", action="store", default="",
+                              help="Comma-separated list of projects to test")
     build_parser.add_argument("-v", "--verbose", action="count", default=0)
     build_parser.set_defaults(func=build)
 
     # compare subcommand
     cmp_parser = subparsers.add_parser(
         "compare",
         help="Comparing two static analyzer runs in terms of "
         "reported warnings and execution time statistics.")

clang/utils/analyzer/SATestBuild.py

For more logging, set the  env variables:
    zaks:TI zaks$ export CCC_ANALYZER_VERBOSE=1
 
 The list of checkers tested are hardcoded in the Checkers variable.
 For testing additional checkers, use the SA_ADDITIONAL_CHECKERS environment
 variable. It should contain a comma separated list.
 """
 import CmpRuns
 import SATestUtils
-from ProjectMap import DownloadType, ProjectInfo, ProjectMap
+from ProjectMap import DownloadType, ProjectInfo
 
 import glob
 import logging
 import math
 import multiprocessing
 import os
 import plistlib
 import shutil

 else:
     TestQueue = Queue  # this will be executed at runtime
 
 
 class RegressionTester:
     """
     A component aggregating all of the project testing.
     """
-    def __init__(self, jobs: int, override_compiler: bool,
-                 extra_analyzer_config: str, regenerate: bool,
-                 strictness: bool):
+    def __init__(self, jobs: int, projects: List[ProjectInfo],
+                 override_compiler: bool, extra_analyzer_config: str,
+                 regenerate: bool, strictness: bool):
         self.jobs = jobs
+        self.projects = projects
         self.override_compiler = override_compiler
         self.extra_analyzer_config = extra_analyzer_config
         self.regenerate = regenerate
         self.strictness = strictness
 
     def test_all(self) -> bool:
         projects_to_test: List[TestInfo] = []
 
-        project_map = ProjectMap()
-
         # Test the projects.
-        for project in project_map.projects:
+        for project in self.projects:
             projects_to_test.append(
                 TestInfo(project,
                          self.override_compiler,
                          self.extra_analyzer_config,
                          self.regenerate, self.strictness))
         if self.jobs <= 1:
             return self._single_threaded_test_all(projects_to_test)
         else: