monadClassKey           = mkPreludeClassUnique 8

 dataClassKey            = mkPreludeClassUnique 9

 functorClassKey         = mkPreludeClassUnique 10

 readClassKey            = mkPreludeClassUnique 13

 realClassKey            = mkPreludeClassUnique 14

 realFloatClassKey       = mkPreludeClassUnique 15

     hi_timestamp <- liftIO $ modificationTimeIfExists (ml_hi_file_ospath location)

     hie_timestamp <- liftIO $ modificationTimeIfExists (ml_hie_file_ospath location)

     let (src_idecls, ord_idecls) = partition ((== IsBoot) . ideclSource . unLoc) imps

         implicit_prelude = xopt LangExt.ImplicitPrelude dflags

   pi_hspp_buf <- liftIO $ hGetStringBuffer pi_hspp_fn

   (pi_srcimps', pi_theimps', L pi_mod_name_loc pi_mod_name)

       <- ExceptT $ do

           return (first (mkMessages . fmap mkDriverPsHeaderMessage . getMessages) mimps)

   let rn_pkg_qual = renameRawPkgQual (hsc_unit_env hsc_env)

   let rn_imps = fmap (\(sp, pk, lmn@(L _ mn)) -> (sp, rn_pkg_qual mn pk, lmn))

   (hspp_buf,mod_name,imps,src_imps) <- do

     buf <- hGetStringBuffer input_fn

     -- TODO: handle implicit knownkey names here?

         rn_imps = fmap (\(s, rpk, lmn@(L _ mn)) -> (s, rn_pkg_qual mn rpk, lmn))

         sec = initSourceErrorContext dflags

     case eimps of

         Left errs -> throwErrors sec (GhcPsMessage <$> errs)

         Right (src_imps,imps, L _ mod_name) -> return

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

 module GHC.Parser.Header

    , mkPrelImports -- used by the renamer too

    , getOptionsFromFile

    , getOptions

 import GHC.Data.Bag

 import GHC.Driver.Errors.Types -- Unfortunate, needed due to the fact we throw exceptions!

 import GHC.Parser.Errors.Types

 import GHC.Utils.Error

 import GHC.Utils.Exception as Exception

 import GHC.Data.StringBuffer

 import GHC.Data.Maybe

 import GHC.Data.FastString

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

 --

 -- Throws a 'SourceError' if parsing fails.

   let loc  = mkRealSrcLoc (mkFastString filename) 1 1

   case unP parseHeader (initParserState popts buf loc) of

     PFailed pst ->

         -- assuming we're not logging warnings here as per below

                 mod = mb_mod `orElse` L (noAnnSrcSpan main_loc) mAIN_NAME

                 (src_idecls, ord_idecls) = partition ((== IsBoot) . ideclSource . unLoc) imps

                 convImport_src (L _ (i :: ImportDecl GhcPs)) = (reLoc $ ideclName i)

               in

                      , reLoc mod)

 mkPrelImports :: ModuleName

               -> Bool -> [LImportDecl GhcPs]

               -> [LImportDecl GhcPs]

 -- The token parser is written manually because Happy can't

 -- return a partial result when it encounters a lexer error.

 -- We want to extract options before the buffer is passed through

 getOptions' :: ParserOpts

             -> SourceErrorContext

             -> [String]

 warnUnusedImport rdr_env (L loc decl, used, unused, unused_wcs)

   -- Do not warn for 'import M()'

   = return ()

   -- Note [Do not warn about Prelude hiding]

               ; checkWiredInTyCon doubleTyCon

               ; numDef <- case lookupDefaultEnv_Directly user_defaults numClassKey of

                    Nothing -> do { integer_ty <- tcMetaTy integerTyConName

                 -- Supply the built-in defaults, but make the user-supplied defaults

                 -- override them.  We put the user-supplied ones last because in `mconcat`

                 -- on `DefaultEnv` the rightmost wins.

           -- ^ Source imports of the module

         ms_textual_imps :: [(ImportLevel, PkgQual, Located ModuleName)],

           -- ^ Non-source imports of the module from the module *text*

         ms_parsed_mod   :: Maybe HsParsedModule,

           -- ^ The parsed, nonrenamed source, if we have it.  This is also

           -- used to support "inline module syntax" in Backpack files.

 import GHC.Internal.Functor.ZipList (ZipList(..))

 import GHC.Internal.Types

 import GHC.Generics

 -- $setup

 -- >>> import Prelude

      bool

      ) where

 -- $setup

 -- >>> import Prelude

     ) where

 import GHC.Internal.Enum

 -- | Returns a list of all values of an enum type

 --

 import GHC.Internal.Num ((-))

 import GHC.List (build)

 import qualified Data.List.NubOrdSet as NubOrdSet

 inits1, tails1 :: [a] -> [NonEmpty a]

 import Data.Bool (Bool(..))

 import GHC.Internal.Data.Function ((.))

 import GHC.Internal.Data.Ord (Ordering(..))

 -- | Implemented as a red-black tree, a la Okasaki.

 data NubOrdSet a

 -- Stability   :  internal

 -- Portability :  non-portable (GHC Extensions)

 --

 module GHC.KnownKeyNames

     ( Rational

     , Foldable, Traversable

     , IsString

     , Functor, Monad

 import GHC.Internal.IO.SubSystem (IoSubSystem(..))

 import Data.Word (Word32,Word64,Word)

 -- | 'RtsTime' is defined as a @StgWord64@ in @stg/Types.h@

 --

 import Prelude (Bool,IO,Read,Show,(<$>))

 import qualified GHC.Internal.Stats as Internal

 import GHC.Generics (Generic)

 import Data.String (String)

 import Data.Eq ((/=))

 import System.IO (IO, hPutStrLn, stderr)

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

 -- exitWith

        )

 import Foreign.Ptr (Ptr)

 import Foreign.C.Types (CInt)

 -- * Obtaining POSIX file descriptors and Windows handles

 {-# LANGUAGE TypeFamilies #-}

 {-# LANGUAGE TypeOperators #-}

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

 -- |

 -- Module      :  GHC.Internal.Data.String

     build-depends: ghc-internal

     other-modules:

       -- dummy module to make Hadrian/GHC build a valid library...

       Dummy

           , "import B"

           ]

         , [ "module B !parse_error where"

           --  of having downsweep return an error for just this module

           , "import C"

           ]

           ]

         , [ "module B where"

           , "!parse_error"

           -- list is just empty. This smells like a parser bug to me but

           -- I'm still documenting this behaviour here.

           , "import C"

 -- We can't test module header parsing errors using the same file as other

 -- on parsing imports:

 --

 --      if errorsFound dflags ms