import Data.IntMap.Strict (IntMap)

 import qualified Data.IntMap.Strict as IM

 import GHC.Iface.Syntax

 import GHC.Unit.Module (Module)

 import GHC.Utils.Outputable

 import GHC.Builtin.PrimOps

 import GHC.Types.SptEntry

 import GHC.ByteCode.Breakpoints

 import GHCi.Message

 import GHCi.RemoteTypes

   get bh = FFIInfo <$> get bh <*> get bh

   put_ bh FFIInfo {..} = put_ bh ffiInfoArgs *> put_ bh ffiInfoRet

     gen_bytecode core_binds stubs foreign_files = do

       let cgi_guts = CgInteractiveGuts wcb_module core_binds

                       (typeEnvTyCons type_env) stubs foreign_files

       trace_if logger (text "Generating ByteCode for" <+> ppr wcb_module)

       mkModuleByteCode hsc_env wcb_module wcb_mod_location cgi_guts

     logger = hsc_logger hsc_env

 import GHC.Iface.Make

 import GHC.Iface.Tidy

 import GHC.Core

 import GHC.Parser.Errors.Types

 -- | Assemble 'WholeCoreBindings' if the interface contains Core bindings.

 iface_core_bindings :: ModIface -> ModLocation -> Maybe WholeCoreBindings

 iface_core_bindings iface wcb_mod_location =

     WholeCoreBindings {

       wcb_bindings = bindings,

       wcb_module = mi_module,

       wcb_mod_location,

       wcb_foreign = foreign'

 -- generates interface files. See Note [hscSimpleIface - mkBootModDetailsTc]

 hscSimpleIface :: HscEnv

                -> Maybe CoreProgram

                -> TcGblEnv

                -> ModSummary

                -> IO (ModIface, ModDetails)

 hscSimpleIface' :: Maybe CoreProgram

                 -> TcGblEnv

                 -> ModSummary

                 -> Hsc (ModIface, ModDetails)

     hsc_env   <- getHscEnv

     logger    <- getLogger

     details   <- liftIO $ mkBootModDetailsTc logger tc_result

     new_iface

         <- {-# SCC "MkFinalIface" #-}

            liftIO $

     -- And the answer is ...

     liftIO $ dumpIfaceStats hsc_env

     return (new_iface, details)

                     Nothing -> hscParse' mod_summary

             tc_result0 <- tcRnModule' mod_summary tc_rn_opts' hpm

             if hsc_src == HsigFile

                         ioMsgMaybe $ hoistTcRnMessage $

                             tcRnMergeSignatures hsc_env hpm tc_result0 iface

                 else return tc_result0

               liftIO $ hscTidy hsc_env simplified_guts

           (iface, _details) <- liftIO $

           liftIO $ hscMaybeWriteIface logger dflags True iface mb_old_hash (ms_location summary)

       -- and generate a simple interface.

       _ -> do

         (iface, _details) <- liftIO $

         liftIO $ hscMaybeWriteIface logger dflags True iface mb_old_hash (ms_location summary)

                     mkForeignRef href (freeReallyRemoteRef inst href)

   return (castForeignRef binding_fref, dep_linkables, this_pkgs_loaded)

 import GHC.Prelude

 import Data.Array

 import GHC.HsToCore.Ticks (Tick (..))

 import GHC.Data.SizedSeq

 import GHC.Unit.Module (Module)

 import GHC.Utils.Binary

 import GHC.Utils.Encoding (utf8EncodeShortByteString)

 import GHC.Utils.Outputable

 import Data.List (intersperse)

 -- | Initialize memory for breakpoint data that is shared between the bytecode

 -- generator and the interpreter.

 or `where` clause of a declaration called "bar", which itself is declared

 in a `let` or `where` clause of the top-level function called "foo".

 -}

 import GHC.Iface.Env

 import GHC.Iface.Errors as Iface_Errors

 import GHC.Tc.Errors.Types

 import GHC.Tc.Utils.Monad

 import GHC.Data.Maybe

 import Control.Monad

 import Data.Map ( toList )

 import System.FilePath

 import System.Directory

         , vcat [ppr ver $$ nest 2 (ppr decl) | (ver,decl) <- mi_decls iface]

         , case mi_simplified_core iface of

             Nothing -> empty

               vcat [ text "extra decls:"

                            $$ nest 2 (vcat ([ppr bs | bs <- eds]))

                    , text "foreign stubs:"

                            $$ nest 2 (ppr fs)

                    ]

 import GHC.Iface.Recomp

 import GHC.Iface.Load

 import GHC.Iface.Ext.Fields

 import GHC.CoreToIface

          , mg_safe_haskell = safe_mode

          , mg_trust_pkg    = self_trust

          , mg_docs         = docs

          }

   = do

       self_recomp <- traverse (mkSelfRecomp hsc_env this_mod (ms_hs_hash mod_summary)) usages

       return $ mkIface_ hsc_env this_mod core_prog hsc_src deps rdr_env import_decls fix_env warns self_trust

 -- | Fully instantiate an interface. Adds fingerprints and potentially code

 -- generator produced information.

           -> ModDetails         -- gotten from mkBootModDetails, probably

           -> ModSummary

           -> Maybe CoreProgram

           -> TcGblEnv           -- Usages, deprecations, etc

           -> IO ModIface

   tc_result@TcGblEnv{ tcg_mod = this_mod,

                       tcg_src = hsc_src,

                       tcg_imports = imports,

                    (imp_trust_own_pkg imports) safe_mode self_recomp

                    docs

                    mod_details

           mkFullIface hsc_env partial_iface Nothing Nothing NoStubs []

          -> Maybe IfaceSelfRecomp

          -> Maybe Docs

          -> ModDetails

          -> PartialModIface

 mkIface_ hsc_env

          this_mod core_prog hsc_src deps rdr_env import_decls fix_env src_warns

 --      only at the TypeEnv.  The previous Tidy phase has

 --      put exactly the info into the TypeEnv that we want

 --      to expose in the interface

   = do

     let home_unit    = hsc_home_unit hsc_env

         semantic_mod = homeModuleNameInstantiation home_unit (moduleName this_mod)

         simplified_core =

           if gopt Opt_WriteIfSimplifiedCore dflags

           else Nothing

         decls  = [ tyThingToIfaceDecl entity

                  | entity <- entities,

       sorted_extra_decls :: Maybe IfaceSimplifiedCore

       sorted_extra_decls = mi_simplified_core iface0 <&> \simpl_core ->

   -- The interface hash depends on:

   --   - the ABI hash, plus

 import GHC.Prelude

 import GHC.ForeignSrcLang

 import GHC.Hs

 import GHC.Iface.Ext.Fields

 import GHC.Iface.Recomp.Types

 import GHC.Unit

 import GHC.Unit.Module.Deps

 import GHC.Unit.Module.Warnings

   -- ^ Extra variable definitions which are **NOT** exposed but when

   -- combined with mi_decls allows us to restart code generation.

   -- See Note [Interface Files with Core Definitions] and Note [Interface File with Core: Sharing RHSs]

   , mi_sc_foreign :: IfaceForeign

   -- ^ Foreign stubs and files to supplement 'mi_extra_decls_'.

   -- See Note [Foreign stubs and TH bytecode linking]

                    }

 instance Binary IfaceSimplifiedCore where

     put_ bh eds

     put_ bh fs

   get bh = do

     eds <- get bh

     fs <- get bh

 emptyPartialModIface :: Module -> PartialModIface

 emptyPartialModIface mod

 instance NFData IfaceSimplifiedCore where

 instance NFData IfaceAbiHashes where

   rnf (IfaceAbiHashes a1 a2 a3 a4 a5 a6)

 import GHC.Driver.DynFlags (DynFlags (targetPlatform), initSDocContext)

 import GHC.ForeignSrcLang (ForeignSrcLang (..))

 import GHC.Iface.Syntax

 import GHC.Prelude

 import GHC.Types.ForeignStubs

 import GHC.Unit.Module.Location

 data WholeCoreBindings = WholeCoreBindings

             { wcb_bindings :: [IfaceBindingX IfaceMaybeRhs IfaceTopBndrInfo] -- ^ serialised tidied core bindings.

             , wcb_module   :: Module  -- ^ The module which the bindings are for

             , wcb_mod_location :: ModLocation -- ^ The location where the sources reside.

               -- | Stubs for foreign declarations and files added via

       _ -> UnhelpfulOther <$> get bh

 newtype BinSrcSpan = BinSrcSpan { unBinSrcSpan :: SrcSpan }

 instance Binary GeneratedSrcSpanDetails where

   put_ bh (OrigSpan ss) = do

         GHC.HsToCore.Arrows

         GHC.HsToCore.Binds

         GHC.HsToCore.Breakpoints

         GHC.HsToCore.Coverage

         GHC.HsToCore.Docs

         GHC.HsToCore.Errors.Ppr

 GHC.Hs.Specificity

 GHC.Hs.Type

 GHC.Hs.Utils

 GHC.HsToCore.Errors.Types

 GHC.HsToCore.Pmc.Solver.Types

 GHC.Iface.Errors.Types

 	# Second compilation starts from interface files, but still can print "a"

 	"$(TEST_HC)" $(TEST_HC_OPTS_INTERACTIVE) TopEnvIface -v1 -fno-hide-source-paths -e "a" -e ":q" -fwrite-if-simplified-core -fwrite-interface

 test('ghcirun003', just_ghci, compile_and_run, [''])

 test('T2589',      just_ghci, compile_and_run, [''])

 test('T2881',      just_ghci, compile_and_run, [''])

 test('T3171',

      [when(opsys('mingw32'),skip),