[analyzer] SATestBuild.py: Make verbosity level a cmd option

[vsavchenko]

Fix global issue

[NoQ]

Sounds great!

I'm still in favor of at least some lit tests for these scripts. It should be as simple as adding a tiny lit substitution - and ta-da, we can write tests.

clang/utils/analyzer/SATestBuild.py

def test(self) -> bool:
         :return tests_passed: Whether tests have passed according
         to the :param strictness: criteria.
         """
         stdout(f" \n\n--- Building project {self.project_name}\n")
 
         start_time = time.time()
 
         project_dir = self.get_project_dir()
-        if VERBOSE == 1:
+        if VERBOSE >= 1:
             stdout(f"  Build directory: {project_dir}.\n")
 
         # Set the build results directory.
         output_dir = self.get_output_dir()
         output_dir = os.path.join(project_dir, output_dir)
 
         self.build(project_dir, output_dir)
         check_build(output_dir)
def build(self, directory: str, output_dir: str):
 
         stdout(f"Log file: {build_log_path}\n")
         stdout(f"Output directory: {output_dir}\n")
 
         remove_log_file(output_dir)
 
         # Clean up scan build results.
         if os.path.exists(output_dir):
-            if VERBOSE == 1:
+            if VERBOSE >= 1:
                 stdout(f"  Removing old results: {output_dir}\n")
 
             shutil.rmtree(output_dir)
 
         assert(not os.path.exists(output_dir))
         os.makedirs(os.path.join(output_dir, LOG_DIR_NAME))
 
         # Build and analyze the project.
def scan_build(self, directory: str, output_dir: str, build_log_file: IO):
                 # 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 += f" -j{MAX_JOBS}"
 
                 command_to_run = command_prefix + command
 
-                if VERBOSE == 1:
+                if VERBOSE >= 1:
                     stdout(f"  Executing: {command_to_run}\n")
 
                 check_call(command_to_run, cwd=cwd,
                            stderr=build_log_file,
                            stdout=build_log_file,
                            env=dict(os.environ, **extra_env),
                            shell=True)
 
def analyze_preprocessed(self, directory: str, output_dir: str):
             # Build and call the analyzer command.
             plist_basename = os.path.join(plist_path, file_name)
             output_option = f"-o '{plist_basename}.plist' "
             command = f"{prefix}{output_option}'{file_name}'"
 
             log_path = os.path.join(fail_path, file_name + ".stderr.txt")
             with open(log_path, "w+") as log_file:
                 try:
-                    if VERBOSE == 1:
+                    if VERBOSE >= 1:
                         stdout(f"  Executing: {command}\n")
 
                     check_call(command, cwd=directory, stderr=log_file,
                                stdout=log_file, shell=True)
 
                 except CalledProcessError as e:
                     stderr(f"Error: Analyzes of {full_file_name} failed. "
                            f"See {log_file.name} for details. "
if len(ref_list) > 1:
         ref_list.sort()
         new_list.sort()
 
     # Iterate and find the differences.
     num_diffs = 0
     for ref_dir, new_dir in zip(ref_list, new_list):
         assert(ref_dir != new_dir)
 
-        if VERBOSE == 1:
+        if VERBOSE >= 1:
             stdout(f"  Comparing Results: {ref_dir} {new_dir}\n")
 
         patched_source = os.path.join(directory, PATCHED_SOURCE_DIR_NAME)
 
         # TODO: get rid of option parser invocation here
         opts, args = CmpRuns.generate_option_parser().parse_args(
             ["--rootA", "", "--rootB", patched_source])
         # Scan the results, delete empty plist files.
def get_build_log_path(output_dir: str) -> str:
     return os.path.join(output_dir, LOG_DIR_NAME, BUILD_LOG_NAME)
 
 
 def remove_log_file(output_dir: str):
     build_log_path = get_build_log_path(output_dir)
 
     # Clean up the log file.
     if os.path.exists(build_log_path):
-        if VERBOSE == 1:
+        if VERBOSE >= 1:
             stdout(f"  Removing log file: {build_log_path}\n")
 
         os.remove(build_log_path)
 
 
 def clean_up_empty_plists(output_dir: str):
     """
     A plist file is created for each call to the analyzer(each source file).
for project_info in get_projects(map_file):
         if project_info[1] not in ('0', '1', '2'):
             stderr("Error: Second entry in the project map file should be 0"
                    " (single file), 1 (project), or 2(single file c++11).")
             raise Exception()
 
 
 if __name__ == "__main__":
     # Parse command line arguments.
-    Parser = argparse.ArgumentParser(
+    parser = argparse.ArgumentParser(
         description="Test the Clang Static Analyzer.")
 
-    Parser.add_argument("--strictness", dest="strictness", type=int, default=0,
+    parser.add_argument("--strictness", dest="strictness", type=int, default=0,
                         help="0 to fail on runtime errors, 1 to fail when the "
                         "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",
+    parser.add_argument("-r", dest="regenerate", action="store_true",
                         default=False, help="Regenerate reference output.")
-    Parser.add_argument("--override-compiler", action="store_true",
+    parser.add_argument("--override-compiler", action="store_true",
                         default=False, help="Call scan-build with "
                         "--override-compiler option.")
-    Parser.add_argument("-j", "--jobs", dest="jobs", type=int,
+    parser.add_argument("-j", "--jobs", dest="jobs", type=int,
                         default=0,
                         help="Number of projects to test concurrently")
-    Parser.add_argument("--extra-analyzer-config",
+    parser.add_argument("--extra-analyzer-config",
                         dest="extra_analyzer_config", type=str,
                         default="",
                         help="Arguments passed to to -analyzer-config")
+    parser.add_argument("-v", "--verbose", action="count", default=0)
 
-    args = Parser.parse_args()
+    args = parser.parse_args()
 
+    VERBOSE = args.verbose
     tester = RegressionTester(args.jobs, args.override_compiler,
                               args.extra_analyzer_config, args.regenerate,
                               args.strictness)
     tests_passed = tester.test_all()
 
     if not tests_passed:
         stderr("ERROR: Tests failed.")
         sys.exit(42)