[lit] Replace echo_all_commands with run_with_command_output.

[varungandhi-apple]

Summary

Rename LitConfig's internal field name for clarity.

[varungandhi-apple]

Please review D82791: "[lit] Improve lit's output with default settings and --verbose." and D82811 "[lit] Highlight failing line with colored output." before reviewing this revision.

[varungandhi-apple]

Rebase after changes in D82808.

llvm/utils/lit/lit/LitConfig.py

class LitConfig(object):
     """
 
     def __init__(self, progname, path, quiet,
                  useValgrind, valgrindLeakCheck, valgrindArgs,
                  noExecute, debug, isWindows,
                  params, config_prefix = None,
                  maxIndividualTestTime = 0,
                  parallelism_groups = {},
-                 echo_all_commands=False,
                  script_output_style=OutputSettings.NO_SCRIPT,
                  command_output_style=OutputSettings.ONLY_FAILING_COMMAND):
         # The name of the test runner.
         self.progname = progname
         # The items to add to the PATH environment variable.
         self.path = [str(p) for p in path]
         self.quiet = bool(quiet)
         self.useValgrind = bool(useValgrind)
def __init__(self, progname, path, quiet,
                 self.valgrindArgs.append('--leak-check=full')
             else:
                 # The default is 'summary'.
                 self.valgrindArgs.append('--leak-check=no')
             self.valgrindArgs.extend(self.valgrindUserArgs)
 
         self.maxIndividualTestTime = maxIndividualTestTime
         self.parallelism_groups = parallelism_groups
-        self.echo_all_commands = echo_all_commands
+        # If we call out to an external shell, we ask for all output,
+        # regardless of whether we're going to display all commands that were
+        # run, or only the last command which failed.
+        self.run_with_command_output = (
+            (command_output_style
+             == OutputSettings.UP_TO_AND_INCLUDING_FAILING_COMMAND)
+            or command_output_style == OutputSettings.ONLY_FAILING_COMMAND)
         self.script_output_style = script_output_style
         self.command_output_style = command_output_style
 
     @property
     def maxIndividualTestTime(self):
         """
             Interface for getting maximum time to spend executing
             a single test

llvm/utils/lit/lit/TestRunner.py

def executeScript(test, litConfig, tmpBase, commands, cwd):
     if litConfig.isWindows and not isWin32CMDEXE:
         mode += 'b'  # Avoid CRLFs when writing bash scripts.
     elif sys.version_info > (3,0):
         open_kwargs['encoding'] = 'utf-8'
     f = open(script, mode, **open_kwargs)
     if isWin32CMDEXE:
         for i, ln in enumerate(commands):
             commands[i] = re.sub(kPdbgRegex, "echo '\\1' > nul && ", ln)
-        if litConfig.echo_all_commands:
+        if litConfig.run_with_command_output:
             f.write('@echo on\n')
         else:
             f.write('@echo off\n')
         f.write('\n@if %ERRORLEVEL% NEQ 0 EXIT\n'.join(commands))
     else:
         for i, ln in enumerate(commands):
             commands[i] = re.sub(kPdbgRegex, ": '\\1'; ", ln)
         if test.config.pipefail:
             f.write(b'set -o pipefail;' if mode == 'wb' else 'set -o pipefail;')
-        if litConfig.echo_all_commands:
+        if litConfig.run_with_command_output:
             f.write(b'set -x;' if mode == 'wb' else 'set -x;')
         if sys.version_info > (3,0) and mode == 'wb':
             f.write(bytes('{ ' + '; } &&\n{ '.join(commands) + '; }', 'utf-8'))
         else:
             f.write('{ ' + '; } &&\n{ '.join(commands) + '; }')
     f.write(b'\n' if mode == 'wb' else '\n')
     f.close()
 

llvm/utils/lit/lit/cl_arguments.py

def parse_args():
     env_args = shlex.split(os.environ.get("LIT_OPTS", ""))
     args = sys.argv[1:] + env_args
     opts = parser.parse_args(args)
 
     # default output settings
     opts.show_output_on_failure = True
     opts.script_output_style = OutputSettings.NO_SCRIPT
     opts.command_output_style = OutputSettings.ONLY_FAILING_COMMAND
-    opts.echo_all_commands = True
 
     if opts.quiet:
         opts.show_output_on_failure = False
         opts.command_output_style = OutputSettings.NO_COMMAND
     elif opts.verbose or opts.showAllOutput:
         opts.script_output_style = OutputSettings.FULL_SCRIPT
         opts.command_output_style = (
             OutputSettings.UP_TO_AND_INCLUDING_FAILING_COMMAND
         )
 
-    # If we call out to an external shell, we ask for all output,
-    # regardless of whether we're going to display all commands that were run,
-    # or only the last command which failed.
-    cmd_output_style = opts.command_output_style
-    opts.echo_all_commands = (
-        cmd_output_style == OutputSettings.UP_TO_AND_INCLUDING_FAILING_COMMAND
-        or cmd_output_style == OutputSettings.ONLY_FAILING_COMMAND)
-
     # TODO(python3): Could be enum
     if opts.shuffle:
         opts.order = 'random'
     elif opts.incremental:
         opts.order = 'failing-first'
     else:
         opts.order = 'default'
 

llvm/utils/lit/lit/main.py

lit_config = lit.LitConfig.LitConfig(
         useValgrind=opts.useValgrind,
         valgrindLeakCheck=opts.valgrindLeakCheck,
         valgrindArgs=opts.valgrindArgs,
         noExecute=opts.noExecute,
         debug=opts.debug,
         isWindows=is_windows,
         params=params,
         config_prefix=opts.configPrefix,
-        echo_all_commands=opts.echo_all_commands,
         script_output_style=opts.script_output_style,
         command_output_style=opts.command_output_style)
 
     discovered_tests = lit.discovery.find_tests_for_inputs(lit_config, opts.test_paths)
     if not discovered_tests:
         sys.stderr.write('error: did not discover any tests for provided path(s)\n')
         sys.exit(2)