ModuleGraph, emptyMG, mapMG, mkModuleGraph, mgModSummaries,

         mgLookupModule,

         ModSummary(..), ms_mod_name, ModLocation(..),

         getModSummary,

         getModuleGraph,

         isLoaded,

 import System.Exit      ( exitWith, ExitCode(..) )

 import System.FilePath

 import System.IO.Error  ( isDoesNotExistError )

 #if defined(HAVE_INTERNAL_INTERPRETER)

 import Foreign.C

 -- a module by using 'getModSummary'

 --

 -- XXX: Explain pre-conditions

 getModuleSourceAndFlags m = do

     Nothing -> throwIO $ mkApiErr (ms_hspp_opts m) (text "No source available for module " <+> ppr (ms_mod m))

     Just sourceFile -> do

         return (sourceFile, source, ms_hspp_opts m)

 getTokenStream :: ModSummary -> IO [Located Token]

 getTokenStream mod = do

   (sourceFile, source, dflags) <- getModuleSourceAndFlags mod

   case lexTokenStream (initParserOpts dflags) source startLoc of

     POk _ ts    -> return ts

     PFailed pst -> throwErrors (initSourceErrorContext dflags) (GhcPsMessage <$> getPsErrorMessages pst)

 getRichTokenStream :: ModSummary -> IO [(Located Token, String)]

 getRichTokenStream mod = do

   (sourceFile, source, dflags) <- getModuleSourceAndFlags mod

   case lexTokenStream (initParserOpts dflags) source startLoc of

     POk _ ts    -> return $ addSourceToTokens startLoc source ts

     PFailed pst -> throwErrors (initSourceErrorContext dflags) (GhcPsMessage <$> getPsErrorMessages pst)

 import GHC.Cmm

 import GHC.Cmm.Reg ( pprGlobalReg, pprGlobalRegUse )

 import GHC.Cmm.Utils

 import GHC.Unit.Module

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

       rangeRating (span, _)

         | srcSpanFile span == thisFile = 1

         | otherwise                    = 2 :: Int

       -- Returns block tree for this scope as well as all nested

       -- scopes. Note that if there are multiple blocks in the (exact)

 -- If we want to generate debug info, we put a source note on the

 -- worker. This is useful, especially for heap profiling.

 tick_it generate_debug_info mod_loc name

   | RealSrcSpan span _ <- nameSrcSpan name = tick span

   where

     tick span  = Tick $ SourceNote span $

                  LexicalFastString $ mkFastString $

                  renderWithContext defaultSDocContext $ ppr name

         mkFastStringBytes,

         mkFastStringByteList,

         mkFastString#,

         -- ** Deconstruction

         unpackFS,           -- :: FastString -> String

 import qualified Data.ByteString.Char8    as BSC

 import qualified Data.ByteString.Unsafe   as BS

 import qualified Data.ByteString.Short    as SBS

 import Data.Data

 import Data.IORef

 import Data.Semigroup as Semi

 import Foreign

 mkFastStringShortByteString sbs =

   inlinePerformIO $ mkFastStringWith (mkNewFastStringShortByteString sbs) sbs

 -- | Creates a UTF-8 encoded 'FastString' from a 'String'

 mkFastString :: String -> FastString

 {-# NOINLINE[1] mkFastString #-}

   , unsafeDecodeUtf

   , unsafeEncodeUtf

   , os

   -- * Common utility functions

   , (</>)

   , (<.>)

 import GHC.Utils.Misc (HasCallStack)

 import GHC.Utils.Panic (panic)

 import System.OsPath

 import System.OsString (isSuffixOf)

 -- | Decode an 'OsPath' to 'FilePath', throwing an 'error' if decoding failed.

 -- Prefer 'decodeUtf' and gracious error handling.

 unsafeDecodeUtf :: HasCallStack => OsPath -> FilePath

 unsafeDecodeUtf p =

   either (\err -> panic $ "Failed to decodeUtf \"" ++ show p ++ "\", because: " ++ show err) id (decodeUtf p)

          -- * Creation\/destruction

         hGetStringBuffer,

         hGetStringBufferBlock,

         hPutStringBuffer,

         appendStringBuffers,

         stringToStringBuffer,

 import GHC.Prelude

 import GHC.Data.FastString

 import GHC.Utils.Encoding

 import GHC.Utils.IO.Unsafe

 import GHC.Utils.Panic.Plain

 import Data.Maybe

 import System.IO

 import qualified Data.ByteString.Internal as BS

 import qualified Data.ByteString as BS

 hGetStringBuffer :: FilePath -> IO StringBuffer

 hGetStringBuffer fname = do

    h <- openBinaryFile fname ReadMode

    size_i <- hFileSize h

    offset_i <- skipBOM h size_i 0  -- offset is 0 initially

    let size = fromIntegral $ size_i - offset_i

 recordInfo bndr new_rhs = do

   modLoc <- asks rModLocation

   let

     -- A span from the ticks surrounding the new_rhs

     best_span = quickSourcePos thisFile new_rhs

     -- A back-up span if the bndr had a source position, many do not (think internally generated ids)

 {-# LANGUAGE ViewPatterns #-}

 -- | Module location

 module GHC.Unit.Module.Location

    , addBootSuffix

    , addBootSuffixLocn

    , addBootSuffixLocnOut

    , removeBootSuffix

    , mkFileSrcSpan

    )

 where

 import GHC.Prelude

 import GHC.Data.OsPath

 import GHC.Types.SrcLoc

 import GHC.Utils.Outputable

 import qualified System.OsString as OsString

 -- | Compute a 'SrcSpan' from a 'ModLocation'.

 mkFileSrcSpan :: ModLocation -> SrcSpan

 mkFileSrcSpan mod_loc

       Nothing        -> interactiveSrcSpan   -- Presumably

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

 -- Helpers for backwards compatibility

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

 import GHC.Types.Basic

 import GHC.Data.Maybe

 import GHC.Data.StringBuffer ( StringBuffer )

 import GHC.Utils.Fingerprint

         = ms_mod_name summary == m && ms_unitid summary == unitId

     summary `matches` Target { targetId = TargetFile f _, targetUnitId = unitid }

         | Just f' <- ml_hs_file (ms_location summary)

     _ `matches` _

         = False

                    containers >= 0.6.2.1 && < 0.9,

                    array      >= 0.1 && < 0.6,

                    filepath   >= 1.5 && < 1.6,

                    os-string  >= 2.0.1 && < 2.1,

                    hpc        >= 0.6 && < 0.8,

                    transformers >= 0.5 && < 0.7,

   -- with the module summary information

   let modName = ms_mod_name ms

       modLoc = ms_location ms

 -- | Load a module graph and report the result

 convertToFixed (ModuleNodeCompile ms) =

   let modName = ms_mod_name ms

       modLoc = ms_location ms

 -- | Test a module graph and report if it matches expected invariant violations

 testModuleGraph :: String -> ModuleGraph -> [ModuleGraphInvariantError] -> Ghc ()