issues: #27055

 mrs: !15888

 description: {

 }

 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

       = sep [text "BCO", ppr nm, text "with",

              ppr (sizeFlatBag lits), text "lits",

              ppr (sizeFlatBag ptrs), text "ptrs" ]

                     Nothing -> hscParse' mod_summary

             tc_result0 <- tcRnModule' mod_summary keep_rn' hpm

             if hsc_src == HsigFile

                         ioMsgMaybe $ hoistTcRnMessage $

                             tcRnMergeSignatures hsc_env hpm tc_result0 iface

                 else return tc_result0

                -- we will decide if we need them or not.

                bc_linkable <- checkByteCode checked_iface mod_summary (homeMod_bytecode old_linkable)

                obj_linkable <- liftIO $ checkObjects lcl_dflags (homeMod_object old_linkable) mod_summary

                let just_bc = justBytecode <$> bc_linkable

                    just_o  = justObjects  <$> obj_linkable

 -- | 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,

     }

   where

     ModIface {mi_module, mi_simplified_core} = iface

     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)

       generateByteCode hsc_env cgi_guts wcb_mod_location

     logger = hsc_logger hsc_env

               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)

 -- generates interface files. See Note [simpleTidyPgm - 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)

 -- See Note [ModBreaks vs InternalModBreaks] and Note [Breakpoint identifiers]

 module GHC.HsToCore.Breakpoints

   ( -- * ModBreaks

     -- ** Re-exports BreakpointId

   , BreakpointId(..), BreakTickIndex

 import Data.Array

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

 import GHC.Data.SizedSeq

 import GHC.Unit.Module (Module)

 import GHC.Utils.Outputable

 import Data.List (intersperse)

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

 -- generator and the interpreter.

 --

                 ]

           | otherwise = listArray (0, -1) []

      in ModBreaks

       , modBreaks_vars   = varsTicks

       , modBreaks_decls  = declsTicks

       , modBreaks_ccs    = ccs

   { uc_safe_implicit_imps_req :: !Bool -- ^ Are all implicit imports required to be safe for this Safe Haskell mode?

   }

 mkUsageInfo :: UsageConfig -> Plugins -> FinderCache -> UnitEnv

             -> Module -> ImportedMods -> [ImportUserSpec] -> NameSet

             -> [FilePath] -> [(Module, Fingerprint)] -> [Linkable] -> PkgsLoaded

                                     }

                                | (mod, hash) <- merged ]

                             ++ object_usages

 {- Note [Plugin dependencies]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 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)

         entities = typeEnvElts type_env

         show_linear_types = xopt LangExt.LinearTypes (hsc_dflags hsc_env)

         decls  = [ tyThingToIfaceDecl show_linear_types entity

                  | entity <- entities,

                    let name = getName entity,

       sorted_extra_decls :: Maybe IfaceSimplifiedCore

       sorted_extra_decls = mi_simplified_core iface0 <&> \simpl_core ->

   -- The interface hash depends on:

   --   - the ABI hash, plus

    , linkableFilterByteCode

    , linkableFilterNative

    , partitionLinkables

    )

 where

 linkableBCOs :: Linkable -> [CompiledByteCode]

 linkableBCOs l = [ cbc | BCOs cbc <- NE.toList (linkableParts l) ]

 -- | List the native linkable parts (.o/.so/.dll) of a linkable

 linkableNativeParts :: Linkable -> [LinkablePart]

 linkableNativeParts l = NE.filter isNativeCode (linkableParts l)

 getModBreaks hmi

   | Just linkable <- homeModInfoByteCode hmi,

     -- The linkable may have 'DotO's as well; only consider BCOs. See #20570.

   = bc_breaks cbc

   | otherwise

   = Nothing -- probably object code

 {-# LANGUAGE PatternSynonyms #-}

 {-# LANGUAGE ExplicitNamespaces #-}

 {-# LANGUAGE DerivingVia #-}

 -- | Dependencies and Usage of a module

 module GHC.Unit.Module.Deps

    ( Dependencies(dep_direct_mods

    , noDependencies

    , pprDeps

    , Usage (..)

    , HomeModImport (..)

    , HomeModImportedAvails (..)

    , ImportAvails (..)

 import GHC.Utils.Binary

 import GHC.Utils.Outputable

 import Data.List (sortBy, sort, partition)

 import Data.Set (Set)

 import qualified Data.Set as Set

             return UsageHomeModuleInterface { usg_mod_name = mod, usg_unit_id = uid, usg_iface_hash = hash }

           i -> error ("Binary.get(Usage): " ++ show i)

 -- | Records the imports that we depend on from a home module,

 -- for recompilation checking.

 --

 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 }

 -- See Note [Source Location Wrappers]

 instance Binary BinSrcSpan where

         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.Iface.Errors.Types

 GHC.Iface.Ext.Fields

 GHC.Iface.Flags

 GHC.Hs.Specificity

 GHC.Hs.Type

 GHC.Hs.Utils

 GHC.HsToCore.Errors.Types

 GHC.HsToCore.Pmc.Solver.Types

 GHC.Iface.Errors.Types

 instance Bounded a => Bounded (Solo a)

   -- Defined in ‘GHC.Internal.Enum’

 instance Enum a => Enum (Solo a) -- Defined in ‘GHC.Internal.Enum’

 instance Eq a => Eq (Solo a) -- Defined in ‘GHC.Internal.Classes’

 instance Ord a => Ord (Solo a) -- Defined in ‘GHC.Internal.Classes’

 instance Show a => Show (Solo a) -- Defined in ‘GHC.Internal.Show’

 instance Monoid a => Monoid (Solo a)

   -- Defined in ‘GHC.Internal.Base’

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

 	"$(TEST_HC)" $(TEST_HC_OPTS_INTERACTIVE) TopEnvIface -v1 -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),