import GHC.Utils.Error

 import GHC.Utils.Outputable

 import GHC.Utils.Logger

 reportError :: Logger -> NamePprCtx -> DiagOpts -> SrcSpan -> SDoc -> IO ()

 reportError logger nameContext opts span doc = do

 printMessage :: forall a. (Diagnostic a) => Logger -> DiagnosticOpts a -> DiagOpts -> MsgEnvelope a -> IO ()

 printMessage logger msg_opts opts message

   | log_diags_as_json = do

       let

         rendered :: String

         rendered = renderWithContext (log_default_user_context logflags) decorated

       logJsonMsg logger messageClass jsonMessage

   where

     logflags :: LogFlags

     logflags = logFlags logger

     diagnostic :: a

     diagnostic = errMsgDiagnostic message

     severity :: Severity

     severity = errMsgSeverity message

     messageWithHints :: a -> SDoc

     messageWithHints e =

       let main_msg = formatBulleted $ diagnosticMessage msg_opts e

   diagnosticCode = constructorCode @GHC

 instance HasDefaultDiagnosticOpts DriverMessageOpts where

   defaultOpts = DriverMessageOpts (defaultDiagnosticOpts @PsMessage) (defaultDiagnosticOpts @IfaceMessage)

 dupNamesErr :: NE.NonEmpty SrcSpan -> NE.NonEmpty RdrName -> RnM ()

 dupNamesErr locs names

   where

 badQualBndrErr :: RdrName -> TcRnMessage

 badQualBndrErr rdr_name = TcRnQualifiedBinder rdr_name

   diagnosticCode = constructorCode @GHC

 pprTcRnBadlyLevelled :: LevelCheckReason -> Set.Set ThLevelIndex -> ThLevelIndex -> Maybe ErrorItem -> DecoratedSDoc

 pprTcRnBadlyLevelled reason bind_lvls use_lvl lift_attempt = mkDecorated $

          [ fsep [ text "Level error:", pprLevelCheckReason reason

    , mkLocMessageWarningGroups

    , formatDiagnostic

    , getCaretDiagnostic

    , jsonDiagnostic

 import Data.Foldable

 import Data.List.NonEmpty ( NonEmpty (..) )

 import qualified Data.List.NonEmpty as NE

 import Data.Typeable ( Typeable )

 import Numeric.Natural ( Natural )

 import Text.Printf ( printf )

   -- #18516 tracks our progress toward this goal.

   diagnosticCode    :: a -> Maybe DiagnosticCode

 -- | An existential wrapper around an unknown diagnostic.

 data UnknownDiagnostic opts hint where

   UnknownDiagnostic :: (Diagnostic a, Typeable a)

   diagnosticReason       (UnknownDiagnostic _ _ diag) = diagnosticReason diag

   diagnosticHints        (UnknownDiagnostic _ f diag) = map f (diagnosticHints diag)

   diagnosticCode         (UnknownDiagnostic _ _ diag) = diagnosticCode diag

 -- A fallback 'DiagnosticOpts' which can be used when there are no options

 -- for a particular diagnostic.

   SevIgnore -> const mempty

 getCaretDiagnostic :: MessageClass -> SrcSpan -> IO SDoc

   caretDiagnostic <$> getSrcLine (srcSpanFile span) row

   where

     getSrcLine fn i =

             | otherwise = srcSpanEndCol span - 1

         width = max 1 (end - start)

         marginSpace = replicate marginWidth ' ' ++ " |"

         (srcLinePre,  srcLineRest) = splitAt start srcLine

         (srcLineSpan, srcLinePost) = splitAt width srcLineRest

         caretEllipsis | multiline = "..."

                       | otherwise = ""

         caretLine = replicate start ' ' ++ replicate width '^' ++ caretEllipsis

 --

 -- Queries

 --

 import GHC.Driver.Flags

 import GHC.Types.Error

   ( MessageClass (..), Severity (..)

 -- import GHC.Types.Error ()

 import GHC.Types.SrcLoc

 import qualified Data.Map.Strict as Map

 import Data.Map.Strict (Map)

 import Data.List (stripPrefix)

 import Data.Time

 import System.IO

 import Control.Monad

       MCInfo                       -> printErrs msg

       MCFatal                      -> printErrs msg

       MCDiagnostic SevIgnore _ _   -> pure () -- suppress the message

     where

       printOut   = defaultLogActionHPrintDoc  logflags False out

       printErrs  = defaultLogActionHPrintDoc  logflags False err

 --     `defaultLogActionWithHandles`)

 --

 -- This story is tracked by #24113.

     where

       -- Pretty print the warning flag, if any (#10752)

       message :: SDoc

       addCaret = do

         caretDiagnostic <-

             if log_show_caret logflags

             else pure empty

         return $ getPprStyle $ \style ->

           withPprStyle (setStyleColoured True style)

 T14114.hs:4:20: error: [GHC-10498]

     • Conflicting definitions for ‘a’

       Bound at: T14114.hs:4:20

                 T14114.hs:4:22

     • In a pattern synonym declaration

 T14114.hs:5:20: error: [GHC-10498]

     • Conflicting definitions for ‘a’

       Bound at: T14114.hs:5:20

                 T14114.hs:5:22

     • In a pattern synonym declaration

 T14114.hs:6:20: error: [GHC-10498]

     • Conflicting definitions for ‘a’

       Bound at: T14114.hs:6:20

                 T14114.hs:6:22

     • In a pattern synonym declaration

 test('T13349', normal, compile_fail, [''])

 test('T13470', normal, compile_fail, [''])

 test('T14112', normal, compile_fail, [''])

 test('T14507', normal, compile_fail, ['-dsuppress-uniques'])

 test('T15289', normal, compile_fail, [''])

 test('T15685', normal, compile_fail, [''])

 test('rnfail001', normal, compile_fail, [''])

 test('rnfail002', normal, compile_fail, [''])

 test('rnfail003', normal, compile_fail, [''])

 test('rnfail007', normal, compile_fail, [''])

 test('rnfail008', normal, compile_fail, [''])

 test('rnfail009', normal, compile_fail, [''])

     Conflicting definitions for ‘a’

     Bound at: rnfail004.hs:6:5

               rnfail004.hs:7:10

     Conflicting definitions for ‘b’

     Bound at: rnfail004.hs:7:6

               rnfail004.hs:8:8

 test('tcfail035', normal, compile_fail, [''])

 test('tcfail036', normal, compile_fail, [''])

 test('tcfail037', normal, compile_fail, [''])

 test('tcfail040', normal, compile_fail, [''])

 test('tcfail041', normal, compile_fail, [''])

 test('tcfail042', normal, compile_fail, [''])

     Conflicting definitions for ‘==’

     Bound at: tcfail038.hs:7:11-12

               tcfail038.hs:9:11-12

     Conflicting definitions for ‘/=’

     Bound at: tcfail038.hs:8:11-12

               tcfail038.hs:10:11-12