+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>`.

+

+ppOverlapPragma :: forall p. IsPass p => Maybe (LocatedA (OverlapMode (GhcPass p))) -> SDoc

+    Just (L _ (NoOverlap s))    -> maybe_stext (stext s) "{-# NO_OVERLAP #-}"

+    Just (L _ (Overlappable s)) -> maybe_stext (stext s) "{-# OVERLAPPABLE #-}"

+    Just (L _ (Overlapping s))  -> maybe_stext (stext s) "{-# OVERLAPPING #-}"

+    Just (L _ (Overlaps s))     -> maybe_stext (stext s) "{-# OVERLAPS #-}"

+    Just (L _ (Incoherent s))   -> maybe_stext (stext s) "{-# INCOHERENT #-}"

+    Just (L _ (NonCanonical s)) -> maybe_stext (stext s) "{-# INCOHERENT #-}" -- No surface syntax for NONCANONICAL yet

+    stext :: XOverlapMode (GhcPass p) -> SourceText

+    stext s = case (ghcPass @p, s) of

+                (GhcPs, (s,_)) -> s

+                (GhcRn, (s,_)) -> s

+                (GhcTc, s) -> s

+type instance Anno (OverlapMode (GhcPass p)) = SrcSpanAnnA

+import GHC.Parser.Annotation ( AnnPragma )

+

+type instance XOverlapMode  GhcPs = (SourceText, AnnPragma)

+type instance XOverlapMode  GhcRn = (SourceText, AnnPragma)

+type instance XOverlapMode  GhcTc = SourceText

+instance ToHie (LocatedA (OverlapMode GhcRn)) where

+overlap_pragma :: { Maybe (LocatedA (OverlapMode GhcPs)) }

+  : '{-# OVERLAPPABLE'    '#-}' {% fmap Just $ amsA' (sLL $1 $> (Overlappable (getOVERLAPPABLE_PRAGs $1,

+                                       AnnPragma (glR $1) (epTok $2) noAnn noAnn noAnn noAnn noAnn))) }

+  | '{-# OVERLAPPING'     '#-}' {% fmap Just $ amsA' (sLL $1 $> (Overlapping (getOVERLAPPING_PRAGs $1,

+                                       AnnPragma (glR $1) (epTok $2) noAnn noAnn noAnn noAnn noAnn))) }

+  | '{-# OVERLAPS'        '#-}' {% fmap Just $ amsA' (sLL $1 $> (Overlaps (getOVERLAPS_PRAGs $1,

+                                       AnnPragma (glR $1) (epTok $2) noAnn noAnn noAnn noAnn noAnn))) }

+  | '{-# INCOHERENT'      '#-}' {% fmap Just $ amsA' (sLL $1 $> (Incoherent (getINCOHERENT_PRAGs $1,

+                                       AnnPragma (glR $1) (epTok $2) noAnn noAnn noAnn noAnn noAnn))) }

+module GHC.Tc.Deriv ( tcDeriving, DerivInfo(..), tcOverlapMode ) where

+  NoOverlap    s -> NoOverlap    (fst s)

+  Overlappable s -> Overlappable (fst s)

+  Overlapping  s -> Overlapping  (fst s)

+  Overlaps     s -> Overlaps     (fst s)

+  Incoherent   s -> Incoherent   (fst s)

+  NonCanonical s -> NonCanonical (fst s)

+        ; ispec <- newClsInst (fmap (tcOverlapMode . unLoc) overlap_mode) dfun_name

+getOverlapFlag :: Maybe (OverlapMode GhcTc) -- User pragma if any

+                | incoherent_ok               = Incoherent noAnn

+                | overlap_ok                  = Overlaps   noAnn

+                | otherwise                   = NoOverlap  noAnn

+newClsInst :: Maybe (OverlapMode GhcTc)   -- User pragma

+      TH.Overlaps      -> Hs.Overlaps     (SourceText $ fsLit "{-# OVERLAPS", noAnn)

+      TH.Overlappable  -> Hs.Overlappable (SourceText $ fsLit "{-# OVERLAPPABLE", noAnn)

+      TH.Overlapping   -> Hs.Overlapping  (SourceText $ fsLit "{-# OVERLAPPING", noAnn)

+      TH.Incoherent    -> Hs.Incoherent   (SourceText $ fsLit "{-# INCOHERENT", noAnn)

+GHC's behaviour is controlled by options. Options can be specified in four ways:

+(1) directly on the command line; (2) via files (response files); (3) in source

+files, using a pragma; and (4) when using GHCi, from within GHCi.

+

+Command-line arguments are either options, file names or response file arguments

+(see further below).

+GHC's use of response files is similar to that of GCC. A response file argument

+is ``@`` followed immediately by the absolute or relative path identifying the

+response file.

+

+.. note::

+

+    In PowerShell, ``@`` is used to identify a splatting variable. Consequently,

+    GHC response file arguments must be enclosed in quotation marks on the

+    command line to avoid parsing errors.

+

+A response file argument is equivalent to the command-line arguments in the

+response file in the order that they appear in the file. A response file can

+include a response file argument.

+

+In a response file:

+

+* any unescaped whitespace is assumed to separate command-line arguments and is

+  otherwise ignored;

+* a backslash character (``\``) always escapes the following character; and

+* matching pairs of unescaped single quote (``'``) or double quote (``"``)

+  characters escape blocks of characters.

+

+For example,

+    $ cat response-file1

+    @response-file2

+

+    $ cat response-file2

+

+    $ ghc @response-file1

+

+is equivalent to,

+

+.. code-block:: bash

+

+    $ ghc -O1 Hello.hs -o Hello

+  * 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

+

+

+HasCallStack backtrace:

+  throwIO, called at ghc\GHCi\UI.hs:1655:31 in ghc-bin-10.1.20260629-inplace:GHCi.UI

+

+TcPlugin_RewritePerf.hs:24:8: error: [GHC-39999]

+

+instance ExactPrint (OverlapMode GhcPs) where

+  getAnnotationEntry _ = NoEntryVal

+  setAnnotationAnchor a _ _ _ = a

+  exact (NoOverlap (src, AnnPragma o c s l1 l2 t m)) = do

+    return (NoOverlap (src, AnnPragma o' c' s l1 l2 t m))

+  exact (Overlappable (src, AnnPragma o c s l1 l2 t m)) = do

+    return (Overlappable (src, AnnPragma o' c' s l1 l2 t m))

+  exact (Overlapping (src, AnnPragma o c s l1 l2 t m)) = do

+    return (Overlapping (src, AnnPragma o' c' s l1 l2 t m))

+  exact (Overlaps (src, AnnPragma o c s l1 l2 t m)) = do

+    return (Overlaps (src, AnnPragma o' c' s l1 l2 t m))

+  exact (Incoherent (src, AnnPragma o c s l1 l2 t m)) = do

+    return (Incoherent (src, AnnPragma o' c' s l1 l2 t m))

+  exact (NonCanonical (src, AnnPragma o c s l1 l2 t m)) = do

+    return (Incoherent (src, AnnPragma o' c' s l1 l2 t m))

+type instance Anno (OverlapMode DocNameI) = SrcSpanAnnA