import Data.Functor ((<&>))

 import Data.List ( nub, isPrefixOf, partition )

 import qualified Data.List.NonEmpty as NE

 import Control.Monad

 import Data.IORef

 import System.FilePath as FilePath

         if | not (backendGeneratesCode (backend lcl_dflags)) -> do

                -- No need for a linkable, we're good to go

                msg UpToDate

            | not (backendGeneratesCodeForHsBoot (backend lcl_dflags))

            , IsBoot <- isBootSummary mod_summary -> do

                msg UpToDate

            -- Always recompile with the JS backend when TH is enabled until

            -- #23013 is fixed.

                let just_o = justObjects <$> obj_linkable

                    bytecode_or_object_code

                       | otherwise = (justBytecode <$> maybe_bc) `choose` just_o

                    definitely_bc = bc_obj_linkable `prefer` bc_in_memory_linkable

                    -- If not -fwrite-byte-code, then we could use core bindings or object code if that's available.

                    bc_result = if gopt Opt_WriteByteCode lcl_dflags

                                 -- If the byte-code artifact needs to be produced, then we certainly need bytecode.

                                 else maybe_bc

                trace_if (hsc_logger hsc_env)

 -- | Attempt to load bytecode from whole core bindings in the interface if they exist.

 -- This is a legacy code-path, these days it should be preferred to use the bytecode object linkable.

 checkByteCodeFromIfaceCoreBindings _hsc_env iface mod_sum = do

     let

       this_mod   = ms_mod mod_sum

       if_date    = fromJust $ ms_iface_date mod_sum

     case iface_core_bindings iface (ms_location mod_sum) of

       _ -> return $ outOfDateItemBecause MissingBytecode Nothing

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

   HscEnv ->

   ModIface ->

   ModDetails ->

   where

         add_iface_to_hpt iface details hsc_env

         bco <- unsafeInterleaveIO $

 -- | Hydrate interface Core bindings and compile them to bytecode.

 --

 import GHC.Unit.Finder

 import GHC.Unit.Module.ModSummary

 import GHC.Unit.Module.ModIface

 import GHC.Unit.Home.ModInfo

 import GHC.Unit.Home.PackageTable

    (iface, linkable) <- runPipeline (hsc_hooks plugin_hsc_env) pipeline

    -- See Note [ModDetails and --make mode]

    details <- initModDetails plugin_hsc_env iface

  where lcl_dflags  = ms_hspp_opts summary

        location    = ms_location summary

            $ phaseIfFlag hsc_env flag def action

 -- | The complete compilation pipeline, from start to finish

 fullPipeline pipe_env hsc_env pp_fn src_flavour = do

   (dflags, input_fn) <- preprocessPipeline pipe_env hsc_env pp_fn

   let hsc_env' = hscSetFlags dflags hsc_env

   hscPipeline pipe_env (hsc_env_with_plugins, mod_sum, hsc_recomp_status)

 -- | Everything after preprocess

 hscPipeline pipe_env (hsc_env_with_plugins, mod_sum, hsc_recomp_status) = do

   case hsc_recomp_status of

     HscUpToDate iface mb_linkable -> return (iface, mb_linkable)

       hscBackendAction <- use (T_HscPostTc hsc_env_with_plugins mod_sum tc_result warnings mb_old_hash )

       hscBackendPipeline pipe_env hsc_env_with_plugins mod_sum hscBackendAction

 hscBackendPipeline pipe_env hsc_env mod_sum result =

   if backendGeneratesCode (backend (hsc_dflags hsc_env)) then

     do

       return res

   else

     case result of

 hscGenBackendPipeline :: P m

   => PipeEnv

   -> HscEnv

   -> ModSummary

   -> HscBackendAction

 hscGenBackendPipeline pipe_env hsc_env mod_sum result = do

   let mod_name = moduleName (ms_mod mod_sum)

       src_flavour = (ms_hsc_src mod_sum)

   (fos, miface, mlinkable, o_file) <- use (T_HscBackend pipe_env hsc_env mod_name src_flavour location result)

   final_fp <- hscPostBackendPipeline pipe_env hsc_env (ms_hsc_src mod_sum) (backend (hsc_dflags hsc_env)) (Just location) o_file

   final_linkable <-

       -- No object file produced, bytecode or NoBackend

       Nothing -> return mlinkable

       Just o_fp -> do

    as :: P m => Bool -> m (Maybe FilePath)

    as use_cpp = asPipeline use_cpp pipe_env hsc_env Nothing input_fn

    objFromLinkable _ = Nothing

    fromPhase :: P m => Phase -> m (Maybe FilePath)

 import GHC.Unit.Env

 import GHC.Unit.Finder

 import GHC.Unit.Module

 import GHC.Unit.Home.ModInfo

 import GHC.Iface.Errors.Types

               DotO file ForeignObject -> pure (DotO file ForeignObject)

               DotA fp    -> panic ("adjust_ul DotA " ++ show fp)

               DotDLL fp  -> panic ("adjust_ul DotDLL " ++ show fp)

 {-

 {-# LANGUAGE TypeApplications #-}

 {-# LANGUAGE LambdaCase #-}

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

 --

    , PkgsLoaded

    -- * Linkable

    , mkModuleByteCodeLinkable

    , LinkablePart(..)

    , LinkableObjectSort (..)

 -- | Information we can use to dynamically link modules into the compiler

   { linkableTime     :: !UTCTime

       -- ^ Time at which this linkable was built

       -- (i.e. when the bytecodes were produced,

   , linkableModule   :: !Module

       -- ^ The linkable module itself

     -- ^ Files and chunks of code to link.

 type LinkableSet = ModuleEnv Linkable

       | linkableTime l1 > linkableTime l2 = l1

       | otherwise = l2

   ppr (Linkable when_made mod parts)

      = (text "Linkable" <+> parens (text (show when_made)) <+> ppr mod)

        $$ nest 3 (ppr parts)

   | DotDLL FilePath

       -- ^ Dynamically linked library file (.so, .dll, .dylib)

   | DotGBC ModuleByteCode

     -- ^ A byte-code object, lives only in memory.

   ppr (DotA path)       = text "DotA" <+> text path

   ppr (DotDLL path)     = text "DotDLL" <+> text path

   ppr (DotGBC bco)      = text "DotGBC" <+> ppr bco

 -- | Return true if the linkable only consists of native code (no BCO)

 linkableIsNativeCodeOnly :: Linkable -> Bool

   DotA {}         -> True

   DotDLL {}       -> True

   DotGBC {}       -> False

 -- | Is the part a native library? (.so/.dll)

 isNativeLib :: LinkablePart -> Bool

   DotA {}         -> True

   DotDLL {}       -> True

   DotGBC {}       -> False

 -- | Get the FilePath of linkable part (if applicable)

 linkablePartPath :: LinkablePart -> Maybe FilePath

   DotO fn _       -> Just fn

   DotA fn         -> Just fn

   DotDLL fn       -> Just fn

   DotGBC {}       -> Nothing

 -- | Return the paths of all object code files (.o, .a, .so) contained in this

   DotO fn _       -> [fn]

   DotA fn         -> [fn]

   DotDLL fn       -> [fn]

   DotGBC {}       -> []

 -- | Return the paths of all object files (.o) contained in this 'LinkablePart'.

   DotO fn _ -> [fn]

   DotA _ -> []

   DotDLL _ -> []

   DotGBC bco -> gbc_foreign_files bco

 -- | Retrieve the compiled byte-code from the linkable part.

   Just linkable {linkableParts = new}

 linkablePartNative :: LinkablePart -> [LinkablePart]

   DotGBC bco -> [DotO f ForeignObject | f <- gbc_foreign_files bco]

 linkablePartByteCode :: LinkablePart -> [LinkablePart]

 linkablePartByteCode = \case

 module GHC.Unit.Home.ModInfo

    (

      HomeModInfo (..)

    , homeModInfoObject

    , homeModInfoByteCode

    , emptyHomeModInfoLinkable

    )

 where

 import GHC.Unit.Module.ModIface

 import GHC.Unit.Module.ModDetails

 import GHC.Utils.Outputable

 -- | Information about modules in the package being compiled

 data HomeModInfo = HomeModInfo

 instance Outputable HomeModLinkable where

   ppr (HomeModLinkable l1 l2) = ppr l1 $$ ppr l2

 {-

 Note [Home module build products]

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

 module GHC.Unit.Module.Status

    )

 where

 import GHC.Prelude

 import GHC.Unit

 import GHC.Unit.Module.ModGuts

 import GHC.Unit.Module.ModIface

 import GHC.Utils.Fingerprint

 import GHC.Utils.Outputable

 -- | Status of a module in incremental compilation

 data HscRecompStatus

     -- | Nothing to do because code already exists.

     -- | Recompilation of module, or update of interface is required. Optionally

     -- pass the old interface hash to avoid updating the existing interface when

     -- it has not changed.

           -- changed.

         }

 instance Outputable HscRecompStatus where

   ppr HscUpToDate{} = text "HscUpToDate"

   ppr HscRecompNeeded{} = text "HscRecompNeeded"

 instance Outputable HscBackendAction where

   ppr (HscUpdate mi) = text "Update:" <+> (ppr (mi_module mi))

   ppr (HscRecomp _ ml _mi _mf) = text "Recomp:" <+> ppr ml

             , wcb_foreign :: IfaceForeign

             }

 {-

 Note [Foreign stubs and TH bytecode linking]

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