[lit] Highlight failing line with colored output.

[varungandhi-apple]

Summary

Highlight failing line in lit.py output with color.
Split out from D80694.

[varungandhi-apple]

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

[varungandhi-apple]

Rebase after changes in D82808.

llvm/docs/CommandGuide/lit.rst

  Echo all commands to stdout, as they are being executed.
  This can be valuable for debugging test failures, as the last echoed command
  will be the one which has failed.
  :program:`lit` normally inserts a no-op command (``:`` in the case of bash)
  with argument ``'RUN: at line N'`` before each command pipeline, and this
  option also causes those no-op commands to be echoed to stdout to help you
  locate the source line of the failed command.
 
+ The failing command and corresponding output are highlighted in color if the
+ terminal supports it.
+
 .. option:: -vv, --echo-all-commands
 
  Alias for ``-v``/``--verbose`` (for backwards compatibility).
 .. option:: -a, --show-all
 
  Show more information about all tests, for example the entire test
  commandline and output.
 

llvm/utils/lit/lit/TestRunner.py

 import threading
 
 import io
 try:
     from StringIO import StringIO
 except ImportError:
     from io import StringIO
 
+from lit.ProgressBar import TerminalController
 import lit.OutputSettings as OutputSettings
 from lit.ShCommands import GlobItem, Command
 import lit.ShUtil as ShUtil
 import lit.Test as Test
 import lit.util
 from lit.util import to_bytes, to_string, to_unicode
 from lit.BooleanExpression import BooleanExpression
 
if len(run_lines) == 1:
             return (start, last_run_line.group(0))
 
     last_run_line = run_lines[-1]
     # trim the shell-specific prefix
     delta = first_run_str_start - first_run_line_start
     last_run_line_str = last_run_line.group(0)[delta:]
     return (last_run_line.start(), last_run_line_str)
 
-def make_script_output(lit_config, script_lines, exit_code):
+def highlight_failure_lines(text):
+    term = TerminalController()
+    return term.render('${BOLD}${RED}%s${NORMAL}' % text)
+
+def make_script_output(lit_config, script_lines, stdout, stderr, test_status,
+                       exit_code):
     def make_output(script_display_lines):
         return ("""Script:\n--\n%s\n--\nExit Code: %d\n"""
                 % ('\n'.join(script_display_lines), exit_code))
 
     def default_output():
         return make_output(script_lines)
 
+    def split_on_substring(strings, substring):
+        for i, s in enumerate(strings):
+            if substring in s:
+                return (strings[:i], s, strings[i+1:])
+        return (None, None, None)
+
+    def highlighted_output(last_run_line):
+        (pre, failing_line, post) = split_on_substring(script_lines,
+                                                       last_run_line)
+        if failing_line is None:
+            return default_output()
+        highlighted_failing_line = highlight_failure_lines(failing_line)
+        return make_output(pre + [highlighted_failing_line] + post)
+
     if lit_config.script_output_style == OutputSettings.NO_SCRIPT:
         return ""
 
     assert(lit_config.script_output_style == OutputSettings.FULL_SCRIPT)
+
+    if not test_status.isFailure:
+        return default_output()
+    last_run_line = None
+    if stderr is not None:
+        _, last_run_line = locate_last_run_line(stderr)
+    if (last_run_line is None) and (stdout is not None):
+        _, last_run_line = locate_last_run_line(stdout)
+    if last_run_line is None:
         return default_output()
 
+    return highlighted_output(last_run_line)
+
 def make_command_output(lit_config, cmd_output, stream_name, test_status):
     def make_output(output_str, is_truncated=False):
         format_str = """Command Output (%s, truncated):\n--\n%s\n--\n"""
         format_str += (
             "(NOTE: The failure may depend on previous RUN lines.\n"
             "       Use --verbose to see previous RUN lines and outputs.)\n"
         )
         if not is_truncated:
def make_command_output(lit_config, cmd_output, stream_name, test_status):
     if run_line_str is None or line_start == 0:
         return default_output()
 
     if lit_config.command_output_style == OutputSettings.ONLY_FAILING_COMMAND:
         return make_output(cmd_output[line_start:], is_truncated=True)
 
     assert(lit_config.command_output_style
            == OutputSettings.UP_TO_AND_INCLUDING_FAILING_COMMAND)
-    return make_output(cmd_output, is_truncated=False)
+    failing_lines = highlight_failure_lines(cmd_output[line_start:])
+    return make_output(cmd_output[:line_start] + failing_lines,
+                       is_truncated=False)
 
 def _runShTest(test, litConfig, useExternalSh, script, tmpBase):
     def runOnce(execdir):
         if useExternalSh:
             res = executeScript(test, litConfig, tmpBase, script, execdir)
         else:
             res = executeScriptInternal(test, litConfig, tmpBase, script, execdir)
         if isinstance(res, lit.Test.Result):
for i in range(attempts):
             break
 
     # If we had to run the test more than once, count it as a flaky pass. These
     # will be printed separately in the test summary.
     if i > 0 and status == Test.PASS:
         status = Test.FLAKYPASS
 
     # Form the output log.
-    output = make_script_output(litConfig, script, exitCode)
+    output = make_script_output(litConfig, script, out, err, status, exitCode)
 
     if timeoutInfo is not None:
         output += """Timeout: %s\n""" % (timeoutInfo,)
     output += "\n"
 
     # Append the outputs, if present.
     if out:
         output += make_command_output(litConfig, out, "stdout", status)