GitLab

Ben Gamari pushed to branch wip/T27456 at Glasgow Haskell Compiler / GHC

Commits:

b0c59013

by Ben Gamari at 2026-06-29T11:14:10-04:00

base: Display ExceptionContext in WhileHandling's textual description

As originally-implemented the implementation for
`WhileHandling(displayExceptionAnnotation)` would display the
`ExceptionContext` of the exception which it carries (as this was the
behavior of `displayException`, in terms of which
`displayExceptionAnnotation` was implemented).

However, in 284ffab3 the definition of `SomeException(displayException)`
was changed to exclude the `ExceptionContext`. This means that
`WhileHandling(displayExceptionAnnotation)` fails to describe the
provenance of the exception which it captures, greatly limiting its
utility.

Return the implementation to its originally-specified behavior by
implementing `WhileHandling(displayExceptionAnnotation)` in terms of
`displayExceptionWithInfo`.

Fixes #27456.

3 changed files:

+ changelog.d/T27456
libraries/base/changelog.md
libraries/ghc-internal/src/GHC/Internal/Exception/Type.hs

Changes:

changelog.d/T27456

 +section: base
 +issues: #27456
 +mrs: !
 +synopsis:
 +  Show `ExceptionContext` in `displayExceptionAnnotation` implementation of `WhileHandling`
 +description:
 +  In the past ``displayException`` (in terms of which ``WhileHandling``\'s ``displayExceptionAnnotation` is implemented) was changed to hide ``ExceptionContext``. This regressed the behavior of ``displayExceptionAnnotation`` from that which was originally specified. Restore the intended behavior of showing the ``ExceptionContext`` of the carried exception.
++

libraries/base/changelog.md

@@ -31,6 +31,7 @@
    * Export `labelThread` from `Control.Concurrent`.([CLC proposal #376](https://github.com/haskell/core-libraries-committee/issues/376))
    * Add a new module `System.IO.OS` with operations for obtaining operating-system handles (file descriptors, Windows handles). ([CLC proposal #369](https://github.com/haskell/core-libraries-committee/issues/369))
    * Evaluate backtraces for "error" exceptions at the moment they are thrown. ([CLC proposal #383](https://github.com/haskell/core-libraries-committee/issues/383))
 +  * Show `ExceptionContext` in `displayExceptionAnnotation` implementation of `WhileHandling` ([GHC #27456](https://gitlab.haskell.org/ghc/ghc/-/issues/27456))
    * Hide implementation details when throwing exceptions in throw and throwSTM. ([CLC proposal #387](https://github.com/haskell/core-libraries-committee/issues/387))
    * Change `hIsReadable` and `hIsWritable` such that they always throw a respective exception when encountering a closed or semi-closed handle, not just in the case of a file handle. ([CLC proposal #371](github.com/haskell/core-libraries-committee/issues/371))
    * Annotate `onException` continuation with `WhileHandling`. ([CLC Proposal #397](https://github.com/haskell/core-libraries-committee/issues/397))

libraries/ghc-internal/src/GHC/Internal/Exception/Type.hs

@@ -84,7 +84,7 @@ data WhileHandling = WhileHandling SomeException deriving Show
  instance ExceptionAnnotation WhileHandling where
    displayExceptionAnnotation (WhileHandling e) =
 -    "While handling " ++ case lines $ displayException e of
 +    "While handling " ++ case lines $ displayExceptionWithInfo e of
        [] -> ""
        (l1:ls) ->
          -- Indent lines forward.