GitLab

Sasha Bogicevic pushed to branch wip/21101 at Glasgow Haskell Compiler / GHC

Commits:

d43a7b7a

by Brian McKenna at 2026-07-15T20:10:04+02:00

Strip ticks when desugaring bool guards

The special `considerAccessible` pattern was broken when compiling
with debug info. Compiling with debug info wraps expressions with
`SourceNote` ticks, which broke the internals of the
`desugarBoolGuard` function. Ticks are now ignored within this
function.

Fixes #27360

ede4b17b

by Ben Gamari at 2026-07-15T22:59:53-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.

63b92a32

by Sasha Bogicevic at 2026-07-16T18:26:01+02:00

21101 Error message text for invalid record wildcard match

377dbd90

by Sasha Bogicevic at 2026-07-16T18:26:02+02:00

Improve error message for record wildcards with fieldless constructors

TcRnIllegalWildcardsInConstructor now stores a RecordFieldPart, so the message distinguishes record patterns from record constructions, and its suggested fixes are structured GhcHints (SuggestEmptyRecordBraces, SuggestExplicitConstructorArguments) that tools like HLS can turn into code actions. Storing HsRecFieldContext directly is not possible: GHC.Tc.Errors.Types is reachable from the parser via GHC.Types.Error.Codes, while GHC.Rename.Pat depends on the parser — so we reuse the existing RecordFieldPart mirror and toRecordFieldPart.

Fixes #21101

90d299eb

by Sasha Bogicevic at 2026-07-16T18:26:02+02:00

Record wildcard hints: show them in more contexts, and include arity (#21101)

  Address review feedback on !8673:

  * Emit SuggestExplicitConstructorArguments for record patterns as well
    as record construction, so `f (C {..}) = ...` also suggests rewriting
    to positional form. SuggestEmptyRecordBraces remains pattern-only,
    since `C {}` as an expression would construct a value with all fields
    unset.

  * Store the constructor's visible arity in ConHasPositionalArgs so the
    hint can say how many arguments to write, e.g.

        Apply ‘D’ to its two arguments instead

    The arity is threaded from the parsed declaration through
    LConsWithFields: the per-constructor payload changes from
    Maybe [Located Int] to Either VisArity [Located Int], where
    Left n means the constructor has n unlabelled arguments.

  Updates test baselines: T21101, T9815, T9815b, T9815ghci, T9815bghci.

30 changed files:

+ changelog.d/T27360
+ changelog.d/T27456
compiler/GHC/Hs/Utils.hs
compiler/GHC/HsToCore/Pmc/Desugar.hs
compiler/GHC/Rename/Env.hs
compiler/GHC/Rename/Names.hs
compiler/GHC/Rename/Pat.hs
compiler/GHC/Tc/Errors/Ppr.hs
compiler/GHC/Tc/Errors/Types.hs
compiler/GHC/Types/GREInfo.hs
compiler/GHC/Types/Hint.hs
compiler/GHC/Types/Hint/Ppr.hs
libraries/base/changelog.md
libraries/base/tests/T15349.stderr
libraries/ghc-internal/src/GHC/Internal/Exception/Type.hs
libraries/ghc-internal/tests/backtraces/T14532b.stdout
testsuite/tests/codeGen/should_run/cgrun025.stderr
testsuite/tests/exceptions/T26759.stderr
testsuite/tests/ghc-e/should_fail/T18441fail7.stderr
testsuite/tests/mdo/should_fail/mdofail006.stderr
+ testsuite/tests/pmcheck/should_compile/T27360.hs
testsuite/tests/pmcheck/should_compile/all.T
+ testsuite/tests/rename/should_fail/T21101.hs
+ testsuite/tests/rename/should_fail/T21101.stderr
testsuite/tests/rename/should_fail/T9815.stderr
testsuite/tests/rename/should_fail/T9815b.stderr
testsuite/tests/rename/should_fail/T9815bghci.stderr
testsuite/tests/rename/should_fail/T9815ghci.stderr
testsuite/tests/rename/should_fail/all.T
testsuite/tests/runghc/T7859.stderr-mingw32

Changes:

changelog.d/T27360

 +section: compiler
 +issues: #27360
 +mrs: !16161
 +synopsis:
 +  Recognise ``considerAccessible`` under ticks (``-g``, ``-finfo-table-map``, ``-fhpc`` etc)
 +description:
 +  The pattern-match checker now properly recognises ``considerAccessible`` even
 +  when it is surrounded by ticks (e.g. debug info ticks with ``-g``, with
 +  ``-finfo-table-map``, etc). This ensures it works as advertised, suppressing
 +  redundant pattern-match warnings, even when it occurs under a tick.

changelog.d/T27456

 +section: base
 +issues: #27456
 +mrs: !16275
 +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.
++

compiler/GHC/Hs/Utils.hs

@@ -1613,8 +1613,8 @@ hsConDeclsBinders in the following format:
      with its record fields, in the form of a list of Int indices into...
    - IntMap FieldOcc, an IntMap of record fields.
 -(In actual fact, we use [(ConRdrName, Maybe [Located Int])], with Nothing indicating
 -that the constructor has unlabelled fields: see Note [Local constructor info in the renamer]
 +(In actual fact, we use [(ConRdrName, Either VisArity [Located Int])], with Left n indicating
 +that the constructor has n unlabelled arguments: see Note [Local constructor info in the renamer]
  in GHC.Types.GREInfo.)
  This allows us to do the following (see GHC.Rename.Names.getLocalNonValBinders.new_tc):
@@ -1635,7 +1635,7 @@ Other relevant test cases: rnfail015.
  -- See Note [Collecting record fields in data declarations].
  data LConsWithFields p =
    LConsWithFields
 -    { consWithFieldIndices :: [(LocatedA (IdP (GhcPass p)), Maybe [Located Int])]
 +    { consWithFieldIndices :: [(LocatedA (IdP (GhcPass p)), Either VisArity [Located Int])]
      , consFields :: IntMap (LFieldOcc (GhcPass p))
+     }
@@ -1675,16 +1675,15 @@ hsConDeclsBinders cons = go emptyFieldIndices cons
                  LConsWithFields ns fs = go seen' rs
      get_flds_h98 :: FieldIndices p -> HsConDeclH98Details (GhcPass p)
 -                 -> (Maybe [Located Int], FieldIndices p)
 -    get_flds_h98 seen (RecCon _ flds) = first Just $ get_flds seen flds
 -    get_flds_h98 seen (PrefixCon _ []) = (Just [], seen)
 -    get_flds_h98 seen _ = (Nothing, seen)
 +                 -> (Either VisArity [Located Int], FieldIndices p)
 +    get_flds_h98 seen (RecCon _ flds) = first Right $ get_flds seen flds
 +    get_flds_h98 seen (PrefixCon _ args) = (Left (length args), seen)
 +    get_flds_h98 seen (InfixCon {}) = (Left 2, seen)
      get_flds_gadt :: FieldIndices p -> HsConDeclGADTDetails (GhcPass p)
 -                  -> (Maybe [Located Int], FieldIndices p)
 -    get_flds_gadt seen (RecConGADT _ flds) = first Just $ get_flds seen flds
 -    get_flds_gadt seen (PrefixConGADT _ []) = (Just [], seen)
 -    get_flds_gadt seen _ = (Nothing, seen)
 +                  -> (Either VisArity [Located Int], FieldIndices p)
 +    get_flds_gadt seen (RecConGADT _ flds) = first Right $ get_flds seen flds
 +    get_flds_gadt seen (PrefixConGADT _ args) = (Left (length args), seen)
      get_flds :: FieldIndices p -> LocatedA [LHsConDeclRecField (GhcPass p)]
               -> ([Located Int], FieldIndices p)

compiler/GHC/HsToCore/Pmc/Desugar.hs

@@ -12,7 +12,8 @@ import GHC.Prelude
  import GHC.HsToCore.Pmc.Types
  import GHC.HsToCore.Pmc.Utils
 -import GHC.Core (Expr(Var,App))
 +import GHC.Core (CoreExpr, Expr(Var,App))
 +import GHC.Core.Utils (stripTicksTopE)
  import GHC.Data.FastString (unpackFS, lengthFS, mkFastStringShortText)
  import GHC.Driver.DynFlags
  import GHC.Hs
@@ -474,24 +475,28 @@ desugarLocalBinds _binds = return GdEnd
  -- | Desugar a pattern guard
  --   @pat <- e ==>  let x = e;  <guards for pat <- x>@
  desugarBind :: LPat GhcTc -> LHsExpr GhcTc -> DsM GrdDag
 -desugarBind p e = dsLExpr e >>= \case
 -  Var y
 -    | Nothing <- isDataConId_maybe y
 -    -- RHS is a variable, so that will allow us to omit the let
 -    -> desugarLPat y p
 -  rhs -> do
 -    (x, grds) <- desugarLPatV p
 -    pure (PmLet x rhs `consGrdDag` grds)
 +desugarBind p e =
 +  dsLExpr_stripTicks e >>= \case
 +    Var y
 +      | Nothing <- isDataConId_maybe y
 +      -- RHS is a variable, so that will allow us to omit the let
 +      -> desugarLPat y p
 +    rhs -> do
 +      (x, grds) <- desugarLPatV p
 +      pure (PmLet x rhs `consGrdDag` grds)
  -- | Desugar a boolean guard
  --   @e ==>  let x = e; True <- x@
  desugarBoolGuard :: LHsExpr GhcTc -> DsM GrdDag
  desugarBoolGuard e
 -  | isJust (isTrueLHsExpr e) = return GdEnd
 +  | isJust (isTrueLHsExpr e) -- NB: looks through ticks
      -- The formal thing to do would be to generate (True <- True)
      -- but it is trivial to solve so instead we give back an empty
      -- GrdDag for efficiency
 -  | otherwise = dsLExpr e >>= \case
 +  = return GdEnd
++
 +  | otherwise
 +  = dsLExpr_stripTicks e >>= \case
        Var y
          | Nothing <- isDataConId_maybe y
          -- Omit the let by matching on y
@@ -500,6 +505,19 @@ desugarBoolGuard e
          x <- mkPmId boolTy
          pure $ sequencePmGrds [PmLet x rhs, vanillaConGrd x trueDataCon []]
 +-- | Desugar an expression, stripping off top-level ticks from the resulting
 +-- Core expression.
 +--
 +-- This function is used instead of 'dsLExpr' when we are immediately going to
 +-- inspect the Core (as we do in e.g. 'desugarBoolGuard' or 'desugarBind') to
 +-- make sure we properly look through intervening ticks (fixing #27360).
 +--
 +-- It's not needed when all we do is stash the resulting 'CoreExpr' into a
 +-- 'GrdDag', as the rest of the machinery (such as 'GHC.HsToCore.Pmc.Solver.addCoreCt')
 +-- looks through ticks.
 +dsLExpr_stripTicks :: LHsExpr GhcTc -> DsM CoreExpr
 +dsLExpr_stripTicks e = stripTicksTopE (const True) <$> dsLExpr e
++
  {- Note [Field match order for RecCon]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  The order for RecCon field patterns actually determines evaluation order of

compiler/GHC/Rename/Env.hs

@@ -423,7 +423,10 @@ lookupConstructorInfo qcon@(WithUserRdr _ con_name)
    = do { info <- lookupGREInfo_GRE con_name
         ; case info of
              IAmConLike con_info -> return con_info
 -            UnboundGRE          -> return $ ConInfo (ConIsData []) ConHasPositionalArgs
 +            UnboundGRE          -> return $ ConInfo (ConIsData []) (ConHasPositionalArgs 0)
 +                                                                      -- The arity is a dummy: an unbound constructor never reaches the
 +                                                                      -- code that consults it (see the isUnboundName guard in
 +                                                                      -- GHC.Rename.Pat.rn_dotdot).
              IAmTyCon {}         -> failIllegalTyCon WL_ConLike qcon
              _ -> pprPanic "lookupConstructorInfo: not a ConLike" $
                        vcat [ text "name:" <+> ppr con_name ]

compiler/GHC/Rename/Names.hs

@@ -71,7 +71,7 @@ import GHC.Types.FieldLabel
  import GHC.Types.Hint
  import GHC.Types.SourceFile
  import GHC.Types.SrcLoc as SrcLoc
 -import GHC.Types.Basic  ( TyConFlavour (..), convImportLevel )
 +import GHC.Types.Basic  (TyConFlavour (..), convImportLevel, VisArity)
  import GHC.Types.Id
  import GHC.Types.PkgQual
  import GHC.Types.GREInfo (ConInfo(..), ConFieldInfo (..), ConLikeInfo (ConIsData))
@@ -875,15 +875,16 @@ getLocalNonValBinders fixity_env
      --
      -- The information we needed was all set up for us:
      -- see Note [Collecting record fields in data declarations] in GHC.Hs.Utils.
 -    mk_fld_env :: [(Name, Maybe [Located Int])] -> IntMap FieldLabel
 +    mk_fld_env :: [(Name, Either VisArity [Located Int])] -> IntMap FieldLabel
                 -> [(ConLikeName, ConInfo)]
      mk_fld_env names flds =
        [ (DataConName con, ConInfo (ConIsData (map fst names)) fld_info)
 -      | (con, mb_fl_indxs) <- names
 -      , let fld_info = case fmap (map ((flds IntMap.!) . unLoc)) mb_fl_indxs of
 -              Nothing         -> ConHasPositionalArgs
 -              Just []         -> ConIsNullary
 -              Just (fld:flds) -> ConHasRecordFields $ fld NE.:| flds ]
 +      | (con, con_fl_indxs) <- names
 +      , let fld_info = case fmap (map ((flds IntMap.!) . unLoc)) con_fl_indxs of
 +              Left 0           -> ConIsNullary
 +              Left arity       -> ConHasPositionalArgs arity
 +              Right []         -> ConIsNullary
 +              Right (fld:flds) -> ConHasRecordFields $ fld NE.:| flds ]
      new_assoc :: DuplicateRecordFields -> FieldSelectors -> LInstDecl GhcPs
                -> RnM [GlobalRdrElt]
@@ -939,10 +940,10 @@ getLocalNonValBinders fixity_env
      -- Add errors if a constructor has a duplicate record field.
      add_dup_fld_errs :: IntMap FieldLabel
 -                     -> (Name, Maybe [Located Int])
 +                     -> (Name, Either VisArity [Located Int])
                       -> IOEnv (Env TcGblEnv TcLclEnv) ()
 -    add_dup_fld_errs all_flds (con, mb_con_flds)
 -      | Just con_flds <- mb_con_flds
 +    add_dup_fld_errs all_flds (con, con_flds_or_arity)
 +      | Right con_flds <- con_flds_or_arity
        , let (_, dups) = removeDups (comparing unLoc) con_flds
        = for_ dups $ \ dup_flds ->
            -- Report the error at the location of the second occurrence

compiler/GHC/Rename/Pat.hs

@@ -874,7 +874,11 @@ rnHsRecFields ctxt mk_arg (HsRecFields { rec_flds = flds, rec_dotdot = dotdot })
             ; checkErr dd_flag (needFlagDotDot ctxt)
             ; (rdr_env, lcl_env) <- getRdrEnvs
             ; conInfo <- lookupConstructorInfo qcon
 -           ; when (conFieldInfo conInfo == ConHasPositionalArgs) (addErr (TcRnIllegalWildcardsInConstructor con))
++
 +           ; case conFieldInfo conInfo of
 +               ConHasPositionalArgs nbArgs ->
 +                 addErr $ TcRnIllegalWildcardsInConstructor (toRecordFieldPart ctxt) con nbArgs
 +               _ -> return ()
             ; let present_flds = mkOccSet $ map rdrNameOcc (getFieldRdrs flds)
                     -- For constructor uses (but not patterns)

compiler/GHC/Tc/Errors/Ppr.hs

@@ -357,12 +357,12 @@ instance Diagnostic TcRnMessage where
        -> mkSimpleDecorated $ vcat [text "Illegal view pattern: " <+> ppr pat]
      TcRnCharLiteralOutOfRange c
        -> mkSimpleDecorated $ text "character literal out of range: '\\" <> char c  <> char '\''
 -    TcRnIllegalWildcardsInConstructor con
 +    TcRnIllegalWildcardsInConstructor ctx con _
        -> mkSimpleDecorated $
 -           vcat [ text "Illegal `{..}' notation for constructor" <+> quotes (ppr con)
 -                , nest 2 (text "Record wildcards may not be used for constructors with unlabelled fields.")
 -                , nest 2 (text "Possible fix: Remove the `{..}' and add a match for each field of the constructor.")
 -                ]
 +           text "The data constructor" <+> quotes (ppr con)
 +             <+> text "does not have named record fields, so the record"
 +             <+> pprRecordFieldPart ctx
 +             <+> quotes (ppr con <> text "{..}") <+> text "is invalid."
      TcRnIgnoringAnnotations anns
        -> mkSimpleDecorated $
             text "Ignoring ANN annotation" <> plural anns <> comma
@@ -2791,8 +2791,12 @@ instance Diagnostic TcRnMessage where
        -> [suggestExtension LangExt.ViewPatterns]
      TcRnCharLiteralOutOfRange{}
        -> noHints
 -    TcRnIllegalWildcardsInConstructor{}
 -      -> noHints
 +    TcRnIllegalWildcardsInConstructor ctx con arity
 +      -> case ctx of
 +           RecordFieldPattern{} -> [ SuggestEmptyRecordBraces con
 +                                   , SuggestExplicitConstructorArguments con arity
 +                                   ]
 +           _                    -> [SuggestExplicitConstructorArguments con arity]
      TcRnIgnoringAnnotations{}
        -> noHints
      TcRnAnnotationInSafeHaskell

compiler/GHC/Tc/Errors/Types.hs

@@ -817,17 +817,34 @@ data TcRnMessage where
    TcRnNegativeNumTypeLiteral :: IntegralLit GhcRn -> TcRnMessage
    {-| TcRnIllegalWildcardsInConstructor is an error that occurs whenever
 -      the record wildcards '..' are used inside a constructor without labeled fields.
 +      the record wildcards '..' are used with a constructor whose fields are
 +      positional (unlabelled). The 'RecordFieldPart' field records whether
 +      the wildcards occurred in a record construction (an expression) or in
 +      a record pattern, so that the message and its suggested fixes can be
 +      worded accordingly. Constructors with no fields at all do not trigger
 +      this error: since GHC proposal 496 ("Nullary record wildcards"),
 +      @C {..}@ is legal for nullary constructors.
 +      The 'VisArity' field records the constructor's number of positional arguments
 +      which the suggested fix mentions.
 -      Examples(s): None
 +      Example(s):
++
 +        data D = D Int Bool
++
 +        f :: D -> ()
 +        f D{..} = ()      -- record pattern
++
 +        g :: D
 +        g = D{..}         -- record construction
       Test cases:
         rename/should_fail/T9815.hs
         rename/should_fail/T9815b.hs
         rename/should_fail/T9815ghci.hs
         rename/should_fail/T9815bghci.hs
 +       rename/should_fail/T21101.hs
    -}
 -  TcRnIllegalWildcardsInConstructor :: !Name -> TcRnMessage
 +  TcRnIllegalWildcardsInConstructor :: !RecordFieldPart -> !Name -> !VisArity -> TcRnMessage
    {-| TcRnIgnoringAnnotations is a warning that occurs when the source code
        contains annotation pragmas but the platform in use does not support an

compiler/GHC/Types/GREInfo.hs

@@ -244,14 +244,14 @@ instance NFData ConLikeInfo where
  -- See Note [Local constructor info in the renamer]
  data ConFieldInfo
    = ConHasRecordFields (NonEmpty FieldLabel)
 -  | ConHasPositionalArgs
 +  | ConHasPositionalArgs !VisArity
    | ConIsNullary
    deriving stock Eq
    deriving Data
  instance NFData ConFieldInfo where
    rnf ConIsNullary = ()
 -  rnf ConHasPositionalArgs = ()
 +  rnf (ConHasPositionalArgs arity) = rnf arity
    rnf (ConHasRecordFields flds) = rnf flds
  mkConInfo :: ConLikeInfo -> VisArity -> [FieldLabel] -> ConInfo
@@ -259,9 +259,9 @@ mkConInfo con_ty n flds =
    ConInfo { conLikeInfo  = con_ty
            , conFieldInfo = mkConFieldInfo n flds }
 -mkConFieldInfo :: Arity -> [FieldLabel] -> ConFieldInfo
 +mkConFieldInfo :: VisArity -> [FieldLabel] -> ConFieldInfo
  mkConFieldInfo 0 _ = ConIsNullary
 -mkConFieldInfo _ fields = maybe ConHasPositionalArgs ConHasRecordFields
 +mkConFieldInfo arity fields = maybe (ConHasPositionalArgs arity) ConHasRecordFields
                     $ NonEmpty.nonEmpty fields
  conInfoFields :: ConInfo -> [FieldLabel]
@@ -269,7 +269,7 @@ conInfoFields = conFieldInfoFields . conFieldInfo
  conFieldInfoFields :: ConFieldInfo -> [FieldLabel]
  conFieldInfoFields (ConHasRecordFields fields) = NonEmpty.toList fields
 -conFieldInfoFields ConHasPositionalArgs = []
 +conFieldInfoFields (ConHasPositionalArgs _) = []
  conFieldInfoFields ConIsNullary = []
  instance Outputable ConInfo where
@@ -284,7 +284,7 @@ instance Outputable ConLikeInfo where
  instance Outputable ConFieldInfo where
    ppr ConIsNullary = text "ConIsNullary"
 -  ppr ConHasPositionalArgs = text "ConHasPositionalArgs"
 +  ppr (ConHasPositionalArgs arity) = text "ConHasPositionalArgs" <+> braces (ppr arity)
    ppr (ConHasRecordFields fieldLabels) =
      text "ConHasRecordFields" <+> braces (ppr fieldLabels)

compiler/GHC/Types/Hint.hs

@@ -45,7 +45,7 @@ import GHC.Types.InlinePragma (ActivationGhc)
  import GHC.Types.Name (Name, NameSpace, OccName (occNameFS), isSymOcc, nameOccName)
  import GHC.Types.Name.Reader (RdrName (Unqual), ImpDeclSpec, GlobalRdrElt)
  import GHC.Types.SrcLoc (SrcSpan)
 -import GHC.Types.Basic (RuleName)
 +import GHC.Types.Basic (RuleName, VisArity)
  import GHC.Parser.Errors.Basic
  import GHC.Utils.Outputable
  import GHC.Data.FastString (fsLit)
@@ -548,6 +548,23 @@ data GhcHint
    | SuggestUpgradeForSemaphoreVersionMismatch !SemaphoreUpgradeTarget !Int
      -- ^ The 'Int' is the required protocol version.
 +  {-| Suggest replacing a record wildcard pattern @C {..}@ with @C {}@,
 +      which matches a constructor without binding its fields.
++
 +      Triggered by 'GHC.Tc.Errors.Types.TcRnIllegalWildcardsInConstructor'
 +      in a record pattern.
 +  -}
 +  | SuggestEmptyRecordBraces !Name
++
 +  {-| Suggest applying a constructor directly to its arguments instead
 +      of record syntax, for constructors without labelled fields.
++
 +      Triggered by 'GHC.Tc.Errors.Types.TcRnIllegalWildcardsInConstructor'
 +      in a record construction and record patterns.
 +      The 'VisArity' is the number of positional arguments of the constructor.
 +  -}
 +  | SuggestExplicitConstructorArguments !Name !VisArity
++
  -- | What the user should upgrade to resolve an @-jsem@ semaphore
  --   protocol version mismatch.
  data SemaphoreUpgradeTarget

compiler/GHC/Types/Hint/Ppr.hs

@@ -345,6 +345,12 @@ instance Outputable GhcHint where
                   text "The jobserver uses a newer semaphore protocol than this GHC."
                $$ (text "Upgrade GHC to a version that supports semaphore protocol v"
                    <> int required <> text " to resolve this.")
 +    SuggestEmptyRecordBraces con
 +      -> text "Use" <+> quotes (ppr con <> text "{}") <+> text "instead,"
 +         <+> text "which matches" <+> quotes (ppr con) <+> text "regardless of its fields"
 +    SuggestExplicitConstructorArguments con nbArgs
 +      -> text "Apply" <+> quotes (ppr con) <+> text "to its"
 +         <+> speakNOf nbArgs (text "argument") <+> text "instead"
  perhapsAsPat :: SDoc
  perhapsAsPat = text "Perhaps you meant an as-pattern, which must not be surrounded by whitespace"

libraries/base/changelog.md

@@ -33,6 +33,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/base/tests/T15349.stderr

 -T15349: Uncaught exception ghc-internal:GHC.Internal.Control.Exception.Base.NonTermination:
 +T15349.exe: Uncaught exception ghc-internal:GHC.Internal.Control.Exception.Base.NonTermination:
  <<loop>>
 -While handling thread blocked indefinitely in an MVar operation
 +While handling ghc-internal:GHC.Internal.IO.Exception.BlockedIndefinitelyOnMVar:
 +  |
 +  | thread blocked indefinitely in an MVar operation
  HasCallStack backtrace:
 -  throwIO, called at libraries/ghc-internal/src/GHC/Internal/Control/Monad/ST/Imp.hs:58:37 in ghc-internal:GHC.Internal.Control.Monad.ST.Imp
 +  throwIO, called at libraries\ghc-internal\src\GHC\Internal\Control\Monad\ST\Imp.hs:59:37 in ghc-internal:GHC.Internal.Control.Monad.ST.Imp

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.

libraries/ghc-internal/tests/backtraces/T14532b.stdout

@@ -2,7 +2,14 @@ ghc-internal:GHC.Internal.Exception.ErrorCall:
  Error in Exception Handler
 -While handling Main Error
 +While handling ghc-internal:GHC.Internal.Exception.ErrorCall:
 +  |
 +  | Main Error
 +  |
 +  | My custom Backtraces:
 +  | HasCallStack backtrace:
 +  |   throwIO, called at T14532b.hs:32:6 in main:Main
 +  |
  My custom Backtraces:
  HasCallStack backtrace:
@@ -13,7 +20,14 @@ ghc-internal:GHC.Internal.Exception.ErrorCall:
  Error in Exception Handler
 -While handling Main Error
 +While handling ghc-internal:GHC.Internal.Exception.ErrorCall:
 +  |
 +  | Main Error
 +  |
 +  | My custom Backtraces:
 +  | HasCallStack backtrace:
 +  |   error, called at T14532b.hs:41:6 in main:Main
 +  |
  My custom Backtraces:
  HasCallStack backtrace:

testsuite/tests/codeGen/should_run/cgrun025.stderr

 -"cgrun025"
 +"cgrun025.exe"
  ["cgrun025.hs"]
  GOT PATH
  {-# LANGUAGE ScopedTypeVariables #-}
@@ -27,11 +27,16 @@ main = do
      trace "hello, trace" $
        catch (getEnv "__WURBLE__" >> return ()) (\ (e :: SomeException) -> error "hello, error")
  hello, trace
 -cgrun025: Uncaught exception ghc-internal:GHC.Internal.Exception.ErrorCall:
 +cgrun025.exe: Uncaught exception ghc-internal:GHC.Internal.Exception.ErrorCall:
  hello, error
 -While handling __WURBLE__: getEnv: does not exist (no environment variable)
 +While handling ghc-internal:GHC.Internal.IO.Exception.IOException:
 +  |
 +  | __WURBLE__: getEnv: does not exist (no environment variable)
 +  |
 +  | HasCallStack backtrace:
 +  |   ioException, called at libraries\ghc-internal\src\GHC\Internal\System\Environment.hs:204:26 in ghc-internal:GHC.Internal.System.Environment
  HasCallStack backtrace:
    error, called at cgrun025.hs:25:75 in main:Main

testsuite/tests/exceptions/T26759.stderr

 -T26759: Uncaught exception ghc-internal:GHC.Internal.Exception.ErrorCall:
 +T26759.exe: Uncaught exception ghc-internal:GHC.Internal.Exception.ErrorCall:
  cleanup failure
 -While handling outer failure
 +While handling ghc-internal:GHC.Internal.Exception.ErrorCall:
 +  |
 +  | outer failure
 +  |
 +  | HasCallStack backtrace:
 +  |   throwIO, called at T26759.hs:6:21 in main:Main
  HasCallStack backtrace:
    throwIO, called at T26759.hs:7:22 in main:Main

testsuite/tests/ghc-e/should_fail/T18441fail7.stderr

 -<interactive>: Uncaught exception ghc-9.13-inplace:GHC.Utils.Panic.GhcException:
 +<interactive>: Uncaught exception ghc-10.1-inplace:GHC.Utils.Panic.GhcException:
  IO error:  "Abcde" does not exist
 -While handling IO error:  "Abcde" does not exist
 +While handling ghc-10.1-inplace:GHC.Utils.Panic.GhcException:
 +  |
 +  | IO error:  "Abcde" does not exist
  HasCallStack backtrace:
 -  throwIO, called at compiler/GHC/Utils/Error.hs:512:19 in ghc-9.13-inplace:GHC.Utils.Error
 +  throwIO, called at compiler\GHC\Utils\Error.hs:499:19 in ghc-10.1-inplace:GHC.Utils.Error

testsuite/tests/mdo/should_fail/mdofail006.stderr

 -mdofail006: Uncaught exception ghc-internal:GHC.Internal.IO.Exception.FixIOException:
 +mdofail006.exe: Uncaught exception ghc-internal:GHC.Internal.IO.Exception.FixIOException:
  cyclic evaluation in fixIO
 -While handling thread blocked indefinitely in an MVar operation
 +While handling ghc-internal:GHC.Internal.IO.Exception.BlockedIndefinitelyOnMVar:
 +  |
 +  | thread blocked indefinitely in an MVar operation
  HasCallStack backtrace:
 -  throwIO, called at libraries/ghc-internal/src/GHC/Internal/Control/Monad/Fix.hs:167:37 in ghc-internal:GHC.Internal.Control.Monad.Fix
 +  throwIO, called at libraries\ghc-internal\src\GHC\Internal\Control\Monad\Fix.hs:169:37 in ghc-internal:GHC.Internal.Control.Monad.Fix

testsuite/tests/pmcheck/should_compile/T27360.hs

 +module T27360 where
++
 +import GHC.Exts
++
 +f :: ()
 +f | False, considerAccessible = ()
 +  | otherwise = ()
++
 +g :: ()
 +g | False, True <- considerAccessible = ()
 +  | otherwise = ()

testsuite/tests/pmcheck/should_compile/all.T

@@ -182,3 +182,4 @@ test('T24845', [], compile, [overlapping_incomplete])
  test('T22652', [], compile, [overlapping_incomplete])
  test('T22652a', [], compile, [overlapping_incomplete])
  test('T24867', [], compile_fail, [overlapping_incomplete])
 +test('T27360', normal, compile, [overlapping_incomplete + '-g3'])

testsuite/tests/rename/should_fail/T21101.hs

 +{-# LANGUAGE RecordWildCards #-}
 +module T21101 where
++
 +data D = D Int Bool
++
 +f :: D -> ()
 +f D{..} = ()

testsuite/tests/rename/should_fail/T21101.stderr

 +T21101.hs:7:3: error: [GHC-47217]
 +    The data constructor ‘D’ does not have named record fields, so the record pattern ‘D{..}’ is invalid.
 +    Suggested fixes:
 +      • Use ‘D{}’ instead, which matches ‘D’ regardless of its fields
 +      • Apply ‘D’ to its two arguments instead
++

testsuite/tests/rename/should_fail/T9815.stderr

+-
  T9815.hs:6:13: error: [GHC-47217]
 -    Illegal `{..}' notation for constructor ‘N’
 -      Record wildcards may not be used for constructors with unlabelled fields.
 -      Possible fix: Remove the `{..}' and add a match for each field of the constructor.
 +    The data constructor ‘N’ does not have named record fields, so the record construction ‘N{..}’ is invalid.
 +    Suggested fix: Apply ‘N’ to its one argument instead
++

testsuite/tests/rename/should_fail/T9815b.stderr

+-
  T9815.hs:6:13: error: [GHC-47217]
 -    Illegal `{..}' notation for constructor ‘N’
 -      Record wildcards may not be used for constructors with unlabelled fields.
 -      Possible fix: Remove the `{..}' and add a match for each field of the constructor.
 +    The data constructor ‘N’ does not have named record fields, so the record construction ‘N{..}’ is invalid.
 +    Suggested fix: Apply ‘N’ to its one argument instead
++

testsuite/tests/rename/should_fail/T9815bghci.stderr

 +<interactive>:5:7: error: [GHC-47217]
 +    The data constructor ‘Arg’ does not have named record fields, so the record construction ‘Arg{..}’ is invalid.
 +    Suggested fix: Apply ‘Arg’ to its two arguments instead
 -<interactive>:5:7: [GHC-47217]
 -    Illegal `{..}' notation for constructor ‘Arg’
 -      Record wildcards may not be used for constructors with unlabelled fields.
 -      Possible fix: Remove the `{..}' and add a match for each field of the constructor.

testsuite/tests/rename/should_fail/T9815ghci.stderr

 +<interactive>:3:7: error: [GHC-47217]
 +    The data constructor ‘Data.Semigroup.Arg’ does not have named record fields, so the record construction ‘Data.Semigroup.Arg{..}’ is invalid.
 +    Suggested fix:
 +      Apply ‘Data.Semigroup.Arg’ to its two arguments instead
 -<interactive>:3:7: [GHC-47217]
 -    Illegal `{..}' notation for constructor ‘Data.Semigroup.Arg’
 -      Record wildcards may not be used for constructors with unlabelled fields.
 -      Possible fix: Remove the `{..}' and add a match for each field of the constructor.

testsuite/tests/rename/should_fail/all.T

@@ -186,6 +186,7 @@ test('T18138', normal, compile_fail, [''])
  test('T20147', normal, compile_fail, [''])
  test('RnEmptyStatementGroup1', normal, compile_fail, [''])
  test('RnImplicitBindInMdoNotation', normal, compile_fail, [''])
 +test('T21101', normal, compile_fail, [''])
  test('T21605a', normal, compile_fail, [''])
  test('T21605b', normal, compile_fail, [''])
  test('T21605c', normal, compile_fail, [''])

testsuite/tests/runghc/T7859.stderr-mingw32

@@ -2,7 +2,12 @@ runghc-9.13.20241015.exe: Uncaught exception ghc-internal:GHC.Internal.IO.Except
  defer-type-errors: rawSystem: does not exist (No such file or directory)
 -While handling rawSystem: does not exist (No such file or directory)
 +While handling ghc-internal:GHC.Internal.IO.Exception.IOException:
 +  |
 +  | rawSystem: does not exist (No such file or directory)
 +  |
 +  | HasCallStack backtrace:
 +  |   ioError, called at libraries/ghc-internal/src/GHC/Internal/Foreign/C/Error.hs:<line>:<column> in <package-id>:GHC.Internal.Foreign.C.Error
  HasCallStack backtrace:
    ioError, called at libraries\process\System\Process\Common.hs:239:16 in process-1.6.25.0-inplace:System.Process.Common