getAnnotations, getFirstAnnotations,

     -- ** Screen output

     fatalErrorMsg, fatalErrorMsgS,

     debugTraceMsg, debugTraceMsgS,

   ) where

 import GHC.Prelude hiding ( read )

 import GHC.Driver.DynFlags

 import GHC.Driver.Env

 import GHC.Core.Rules     ( RuleBase, RuleEnv, mkRuleEnv )

 import GHC.Types.SrcLoc

 import GHC.Types.Error

 import GHC.Utils.Outputable as Outputable

 import GHC.Utils.Logger

 import GHC.Utils.Monad

 putMsg :: SDoc -> CoreM ()

 putMsg = msg MCInfo

 -- | Output an error to the screen. Does not cause the compiler to die.

 errorMsg :: SDoc -> CoreM ()

 -- | Output a fatal error to the screen. Does not cause the compiler to die.

 fatalErrorMsgS :: String -> CoreM ()

 import GHC.Unit.Module

 import GHC.Unit.Module.ModGuts

 import GHC.Types.Literal ( litIsLifted )

 import GHC.Types.Id

 import GHC.Types.Id.Info ( IdDetails(..) )

        ; let (_usg, binds', warnings) = initUs_ us $

                               scTopBinds env0 (mg_binds guts)

        ; return (guts { mg_binds = binds' }) }

   where

     warn_msg :: SpecFailWarnings -> SDoc

     warn_msg warnings = text "SpecConstr encountered one or more function(s) with a SPEC argument that resulted in too many arguments," $$

                         text "which resulted in no specialization being generated for these functions:" $$

 import GHC.Driver.DynFlags

 import GHC.Driver.Config

 import GHC.Driver.Config.Core.Rules ( initRuleOpts )

 import GHC.Core.Type  hiding( substTy, substCo, extendTvSubst, zapSubst )

 import GHC.Types.Id.Info

 import GHC.Types.Error

 import GHC.Utils.Monad    ( foldlM )

 import GHC.Utils.Misc

 import GHC.Utils.Outputable

   | wopt Opt_WarnAllMissedSpecs dflags    = doWarn $ WarningWithFlag Opt_WarnAllMissedSpecs

   | otherwise                             = return ()

   where

     allCallersInlined = all (isAnyInlinePragma . idInlinePragma) callers

     doWarn reason =

         (vcat [ hang (text ("Could not specialise imported function") <+> quotes (ppr fn))

                 2 (vcat [ text "when specialising" <+> quotes (ppr caller)

                         | caller <- callers])

                         -- ThreadKilled in particular needs to actually kill the thread.

                         -- So rethrow that and the other async exceptions

                         Just (err :: SomeAsyncException) -> throwIO err

         return Nothing

 import GHC.Platform

 import GHC.Platform.Ways

 import GHC.Driver.Phases

 import GHC.Driver.Env

 import GHC.Driver.Session

 import GHC.Driver.Config.Diagnostic

 import GHC.Driver.Config.Finder

 import GHC.Runtime.Interpreter

 import GHCi.BreakArray

         then cmdLineErrorIO err

         else do

           when (diag_wopt Opt_WarnMissedExtraSharedLib diag_opts)

           pure Nothing

   where

     diag_opts = initDiagOpts (hsc_dflags hsc_env)

       , not loading_dynamic_hs_libs

       , interpreterProfiled interp

       = do

             text "Interpreter failed to load profiled static library" <+> text lib <> char '.' $$

               text " \tTrying dynamic library instead. If this fails try to rebuild" <+>

               text "libraries with profiling support."

 import GHC.Driver.Errors

 import GHC.Driver.Errors.Types (GhcMessage(..), DriverMessage (DriverNoConfiguredLLVMToolchain))

 import GHC.Driver.CmdLine (warnsToMessages)

 {-

 ************************************************************************

                 debugTraceMsg logger 2

                     (text "Error (figuring out LLVM version):" <+>

                       text (show err))

                     [ text "Warning:", nest 9 $

                           text "Couldn't figure out LLVM version!" $$

                           text ("Make sure you have installed LLVM between ["

         emptyMessages, mkDecorated, mkLocMessage,

         mkMsgEnvelope, mkPlainMsgEnvelope, mkPlainErrorMsgEnvelope,

         mkErrorMsgEnvelope,

         mkPlainError,

         mkPlainDiagnostic,

         -- * Issuing messages during compilation

         putMsg, printInfoForUser, printOutputForUser,

         logInfo, logOutput,

         fatalErrorMsg,

         compilationProgressMsg,

         showPass,

   where

     (sev, reason') = diag_reason_severity opts reason

 --

 -- Creating MsgEnvelope(s)

 --

 ghcExit :: Logger -> Int -> IO ()

 ghcExit logger val

   | val == 0  = exitWith ExitSuccess

                    exitWith (ExitFailure val)

 -- -----------------------------------------------------------------------------

 -- Outputting messages from the compiler

 fatalErrorMsg :: Logger -> SDoc -> IO ()

 fatalErrorMsg logger msg =

     logMsg logger MCFatal noSrcSpan $ withPprStyle defaultErrStyle msg

 *** End of Offense ***

 Compilation had errors