+  # GitLab's log viewer renders ANSI colors, but stdout here is not a tty,

+  # so the driver must be told to emit them.

+  RUNTEST_ARGS="${RUNTEST_ARGS:-} --force-colors"

+

+section: base

+issues: #27455

+mrs: !16274

+synopsis:

+  Don't drop `ExceptionContext` in `SomeException(toException)`

+description:

+  Previously the implementation of ``Exception(toException)`` given to `SomeException` would inappropriately drop the carried `ExceptionContext`. Now ``toException = id``, faithfully implementing the semantics proposed in :ref:`CLC Proposal #200 <https://github.com/haskell/core-libraries-committee/issues/200>`.

+

+      DeprecatedTxt (NoSourceText, noAnn) [noLocA $ WithHsDocIdentifiers (StringLiteral NoSourceText (fastStringToShortText msg)) []]

+                     -> Maybe (LocatedA (WarningTxt (GhcPass p)))

+                     -> Maybe (LocatedA (WarningTxt (GhcPass p)))

+import GHC.Parser.Annotation (noLocA, noAnn)

+    IfWarningTxt src mb_cat strs -> WarningTxt (src, noAnn) (noLocA . fromWarningCategory <$> mb_cat) (noLocA <$> map fromIfaceStringLiteralWithNames strs)

+    IfDeprecatedTxt src strs -> DeprecatedTxt (src, noAnn) (noLocA <$> map fromIfaceStringLiteralWithNames strs)

+toIfaceWarningTxt (WarningTxt (src, _) mb_cat strs) = IfWarningTxt src (unLoc . iwc_wc . unLoc <$> mb_cat) (map (toIfaceStringLiteralWithNames . unLoc) strs)

+toIfaceWarningTxt (DeprecatedTxt (src, _) strs) = IfDeprecatedTxt src (map (toIfaceStringLiteralWithNames . unLoc) strs)

+toIfaceStringLiteral sLit = IfStringLiteral (stringLitSourceText sLit) (sl_fs sLit)

+                            {% fmap Just $ amsA' (sLL $1 $> $

+                                DeprecatedTxt (getDEPRECATED_PRAGs $1, AnnPragma (glR $1) (epTok $3) (fst $ unLoc $2) noAnn noAnn noAnn noAnn)

+                                              (snd $ unLoc $2))}

+                            {% fmap Just $ amsA' (sLL $1 $> $

+                                WarningTxt (getWARNING_PRAGs $1, AnnPragma (glR $1) (epTok $4) (fst $ unLoc $3) noAnn noAnn noAnn noAnn)

+                                           $2 (snd $ unLoc $3))}

+                              (WarningTxt (NoSourceText, noAnn) $1 (snd $ unLoc $4)))) }

+                                          (DeprecatedTxt (NoSourceText, noAnn) $ snd $ unLoc $3))) }

+  LocatedA, LocatedN, LocatedAn,

+  SrcSpanAnnA, SrcSpanAnnN,

+type instance XDeprecatedTxt       (GhcPass _) = (SourceText, AnnPragma)

+type instance XWarningTxt          (GhcPass _) = (SourceText, AnnPragma)

+type instance Anno (WarningTxt (GhcPass pass)) = SrcSpanAnnA

+            (NoSourceText, _)   -> pp_ws ws

+            (SourceText src, _) -> ftext src <+> ctg_doc <+> pp_ws ws <+> text "#-}"

+          (NoSourceText, _)   -> pp_ws ds

+          (SourceText src, _) -> ftext src <+> pp_ws ds <+> text "#-}"

+  * The implementation of `toException` in `SomeException`'s `Exception` instance no longer drops exception context, in keeping with the behavior originally proposed in [CLC Proposal #200](https://github.com/haskell/core-libraries-committee/issues/200).

+import GHC.Internal.Base (String, Void, fmap, return, ($), (.), (++), id)

+    -- | 'toException' converts an exception into the existential 'SomeException'

+    -- wrapper type.

+    --

+    -- In doing so, 'toException' should not /add/ an 'ExceptionContext'.

+    --

+    --   - In most cases, the exception does not store its own 'ExceptionContext'.

+    --     The default implementation of 'toException' (which does not store any

+    --     'ExceptionContext') is suitable for these cases.

+    --   - In the rare case that the exception itself stores an 'ExceptionContext',

+    --     this context should be preserved by 'toException'.

+-- | NB: this instance preserves the attached 'ExceptionContext'.

+    toException = id

+parser.add_argument("--force-colors", action="store_true",

+                        help="emit ANSI colors even when stdout is not a tty (e.g. for CI logs)")

+# config.supports_colors deliberately stays tty-based: it also guards

+# terminal-title updates, which must not end up in a CI log.

+term_color.enable_color = config.supports_colors or args.force_colors

+    summary(t, sys.stdout, color=term_color.enable_color, junit_path=args.junit)

+# Whether to emit color escapes; set in runtests.py.

+# For renderers that serve several sinks: `enabled` says whether *this* sink

+# takes color (the summary is written both to stdout and to a plain-text file).

+def colored_if(enabled: bool, color: Color, s: str) -> str:

+    return colored(color, s) if enabled else s

+from term_color import Color, colored_if

+def _result_directory(opts: TestOptions) -> str:

+    # The test's source directory, relative to the GHC source root, so it reads

+    # the same regardless of which directory `make` was invoked from.

+    srcdir = opts.srcdir

+    if srcdir is None:

+        return ''

+    try:

+        return os.path.relpath(srcdir, config.top.parent)

+    except ValueError:

+        # No relative path exists (e.g. different Windows drives); the

+        # absolute path is still more useful than nothing.

+        return str(srcdir)

+

+    directory = _result_directory(opts)

+      directory = _result_directory(opts)

+    directory = _result_directory(opts)

+        return failBecause(message,

+                           stderr=read_stderr(name),

+                           stdout=read_stdout(name))

+        # The diff already contains the mismatching stream; see Note [Redundant

+        # output in test results].

+                           stderr=None if stderr_match.diff else read_stderr(name),

+                           stdout=None if stdout_match.diff else read_stdout(name),

+        # See Note [Redundant output in test results].

+                           stderr=None if stderr_match.diff else read_stderr(name),

+                           stdout=None if stdout_match.diff else read_stdout(name),

+        return path.read_text(encoding='UTF-8', errors='replace')

+        diff = diff_file.read_text(encoding='UTF-8', errors='replace')

+        return path.read_text(encoding='UTF-8', errors='replace')

+        return path.read_text(encoding='UTF-8', errors='replace')

+def summary(t: TestRun, file: TextIO, color=False, junit_path: Optional[Path]=None) -> None:

+

+    if t.unexpected_failures:

+        # Count output blocks rather than results: a test failing in many ways

+        # collapses to a single block.

+        groups = groupTestOutput(t.unexpected_failures)

+        if len(groups) <= MAX_SUMMARY_OUTPUT_TESTS:

+            printTestOutputSummary(file, groups, color, junit_path)

+        else:

+            where = '; see {}'.format(junit_path) if junit_path else ''

+            header = ('Unexpected failures (more than {}, output omitted{}):'

+                      .format(MAX_SUMMARY_OUTPUT_TESTS, where))

+            file.write(colored_if(color, Color.RED, header) + '\n')

+            printTestInfosSummary(file, t.unexpected_failures)

+

+    if t.unexpected_passes:

+        header = 'Unexpected passes:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        printTestInfosSummary(file, t.unexpected_passes)

+

+    if t.unexpected_stat_failures:

+        header = 'Unexpected stat failures:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        printTestInfosSummary(file, t.unexpected_stat_failures)

+

+    if t.framework_failures:

+        header = 'Framework failures:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        printTestInfosSummary(file, t.framework_failures)

+

+    if t.framework_warnings:

+        header = 'Framework warnings:'

+        file.write(colored_if(color, Color.YELLOW, header) + '\n')

+        printTestInfosSummary(file, t.framework_warnings)

+

+    if stopping():

+        warning = 'WARNING: Testsuite run was terminated early'

+        file.write(colored_if(color, Color.YELLOW, warning) + '\n')

+

+         t.unexpected_stat_failures, t.framework_failures], color)

+    summary_header = colored_if(color, summary_color, 'SUMMARY')

+    file.write(summary_header + ' for test run started at '

+def printUnexpectedTests(file: TextIO, testInfoss, color=False):

+        header = 'Unexpected results from:'

+        file.write(colored_if(color, Color.RED, header) + '\n')

+# Per-stream cap on a failing test's output repeated in the final summary.

+MAX_SUMMARY_OUTPUT_LINES = 100

+

+# Above this many output blocks, skip repeating output entirely: the dump

+# would drown out the summary.

+MAX_SUMMARY_OUTPUT_TESTS = 20

+

+# Note [Redundant output in test results]

+# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+# A failing test result carries up to three pieces of output: `diff`, `stdout`

+# and `stderr`. For an output mismatch these overlap: the diff's `+` lines are

+# the very stream that mismatched, normalised. Reporting both would print the

+# same text twice, so the mismatching stream is dropped at the call sites in

+# favour of the diff, which additionally shows what was expected. The *other*

+# stream is kept: on a stdout mismatch, stderr is independent context.

+#

+# The drop is conditional on there being a diff at all: compare_outputs only

+# runs `diff` when config.verbose >= 1, so under -v0 the stream is the only

+# output there is.

+#

+# Note that, since the drop happens at result construction, it also affects the

+# JUnit report (junit.py).

+

+def strip_diff_header(diff: Optional[str]) -> Optional[str]:

+    # Drop diff(1)'s ---/+++ lines: they name normalised files in the test

+    # directory and carry timestamps, which would also keep otherwise

+    # identical failures from being grouped.

+    if diff is None:

+        return None

+    lines = diff.split('\n')

+    if len(lines) >= 2 and lines[0].startswith('--- ') and lines[1].startswith('+++ '):

+        return '\n'.join(lines[2:])

+    return diff

+

+def sorted_results(testInfos: List[TestResult]) -> List[TestResult]:

+    return sorted(testInfos, key=lambda r: (r.testname.lower(), r.directory, r.way))

+

+# A failure-output block: a representative result, its header-stripped diff,

+# and the ways that share it.

+OutputGroup = Tuple[TestResult, Optional[str], List[WayName]]

+

+# Tests that fail identically in several ways (e.g. normal and g1) share one

+# output block, with the ways collected in the header.

+def groupTestOutput(testInfos: List[TestResult]) -> List[OutputGroup]:

+    # Relies on dicts preserving insertion order.

+    groups = {} # type: Dict[Tuple, OutputGroup]

+    for result in sorted_results(testInfos):

+        diff = strip_diff_header(result.diff)

+        key = (result.testname, result.directory, result.reason,

+               diff, result.stdout, result.stderr)

+        groups.setdefault(key, (result, diff, []))[2].append(result.way)

+    return list(groups.values())

+

+def printTestOutputSummary(file: TextIO,

+                           groups: List[OutputGroup],

+                           color: bool=False,

+                           junit_path: Optional[Path]=None) -> None:

+    # Repeat failing tests' captured output in the summary, so one needn't

+    # hunt for it earlier in a possibly very long log; see #16720.

+    header = '=====> Unexpected failures output summary'

+    file.write(colored_if(color, Color.RED, header) + '\n\n')

+

+    where = ', see {}'.format(junit_path) if junit_path else ''

+    for result, diff, ways in groups:

+        header = '=====> {}({}) ({}) [{}]'.format(

+            result.testname, ', '.join(ways), result.directory + os.sep, result.reason)

+        file.write(colored_if(color, Color.RED, header) + '\n')

+        # See Note [Redundant output in test results] for why these don't overlap.

+        for label, contents in [('Output diff (expected vs actual):', diff),

+                                ('Captured stdout:', result.stdout),

+                                ('Captured stderr:', result.stderr)]:

+            if contents and contents.strip():

+                lines = contents.rstrip('\n').split('\n')

+                if len(lines) > MAX_SUMMARY_OUTPUT_LINES:

+                    omitted = len(lines) - MAX_SUMMARY_OUTPUT_LINES

+                    lines = lines[:MAX_SUMMARY_OUTPUT_LINES] \

+                        + ['... ({} more lines omitted{})'.format(omitted, where)]

+                s = colored_if(color, Color.CYAN, label) + '\n' \

+                    + ''.join(l + '\n' for l in lines)

+                # Test output can contain characters that file's encoding

+                # cannot represent; replace rather than crash (cf safe_print).

+                enc = getattr(file, 'encoding', None) or 'utf-8'

+                file.write(s.encode(enc, errors='replace').decode(enc))

+    footer = '<===== end of unexpected failures output summary'

+    file.write(colored_if(color, Color.RED, footer) + '\n\n')

+

+    for result in sorted_results(testInfos):

+        path = os.path.join(result.directory, result.testname)

+        file.write('   {path} [{r.reason}] ({r.way})\n'.format(r=result, path=path))