import Control.Monad.Trans.State

 import Data.IORef

 import GHC.Driver.Env.KnotVars

 -- | The Hsc monad: Passing an environment and diagnostic state

 newtype Hsc a = Hsc (HscEnv -> Messages GhcMessage -> IO (a, Messages GhcMessage))

 instance HasLogger Hsc where

     getLogger = Hsc $ \e w -> return (hsc_logger e, w)

 -- | HscEnv is like 'GHC.Driver.Monad.Session', except that some of the fields are immutable.

 -- An HscEnv is used to compile a single module from plain Haskell source

 -- code (after preprocessing) to either C, assembly or C--. It's also used

                 -- ^ target code interpreter (if any) to use for TH and GHCi.

                 -- See Note [Target code interpreter]

         , hsc_plugins :: !Plugins

                 -- ^ Plugins

                   , hsc_FC             = fc_var

                   , hsc_type_env_vars  = emptyKnotVars

                   , hsc_interp         = Nothing

                   , hsc_unit_env       = unit_env

                   , hsc_plugins        = emptyPlugins

                   , hsc_hooks          = emptyHooks

   -- Take lock for the actual work.

   (dep_linkables, dep_units) <- modifyLoaderState interp $ \pls -> do

     -- Find what packages and linkables are required

     -- We update the LinkerState even if the JS interpreter maintains its linker

     -- state independently to load new objects here.

   ( LinkDepsOpts (..)

   , LinkDeps (..)

   , getLinkDeps

   )

 where

   , ldGetDependencies :: !([Module] -> IO ([Module], UniqDSet UnitId))

   }

 -- | Find all the packages and linkables that a set of modules depends on

 --

 -- Return the module and package dependencies for the needed modules.

   -> [Module]     -- If you need these

   -> IO LinkDeps  -- ... then link these first

 getLinkDeps opts interp pls span mods = do

   :: LinkDepsOpts

   -> LoaderState

   -> SrcSpan

   -> [Module]

       -- Three step process:

                  Just linkable -> Right linkable

                  Nothing -> Left mod

         -- 3.  For each dependent module, find its linkable

         --     This will either be in the HPT or (in the case of one-shot

         --     compilation) we may need to use maybe_getFileLinkable

       return link_deps

   where

     unit_env = ldUnitEnv opts

     no_obj :: Outputable a => a -> IO b

     no_obj mod = dieWith opts span $

    , initLinkDepsOpts

    , getGccSearchDirectory

    , mkDynLoadLib

    )

 where

   -> IO (LoaderState, SuccessFlag, [LinkableUsage], PkgsLoaded) -- ^ returns the set of linkables required

 -- When called, the loader state must have been initialized (see `initLoaderState`)

 loadDependencies interp hsc_env pls span needed_mods = do

    -- Find what packages and linkables are required

    let this_pkgs_needed = ldNeededUnits deps

       sequence (lookupModuleEnv eps_iface_bytecode mod)

 findBytecodeLinkableMaybe :: HscEnv -> ModLocation -> IO (Maybe Linkable)

 findBytecodeLinkableMaybe hsc_env locn = do

   let bytecode_fn    = ml_bytecode_file locn

 {-# LANGUAGE TypeApplications #-}

 {-# LANGUAGE LambdaCase #-}

 {-# LANGUAGE DeriveTraversable #-}

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

 --

    , mkLinkableUsage

    , ModuleByteCode(..)

    )

 where

 import GHC.Types.Name.Env      ( NameEnv, emptyNameEnv, extendNameEnvList, lookupNameEnv )

 import GHC.Types.Name          ( Name )

 import GHC.Types.SptEntry

 import GHC.Types.Unique.DSet

 import GHC.Types.Unique.DFM

 import GHC.Unit.Module.Deps (LinkablePartUsage (..), linkablePartUsageObjectPaths)

   ppr (DLLPath f) = text "DLLPath" <+> text f

   ppr (Framework s) = text "Framework" <+> text s

   ppr (BytecodeLibrary f) = text "BytecodeLibrary" <+> text f