module GHC.Driver.Env.Types

   ( Hsc(..)

   , HscEnv(..)

   ) where

 import GHC.Driver.Errors.Types ( GhcMessage )

 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

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

                 -- See Note [Target code interpreter]

         , hsc_plugins :: !Plugins

                 -- ^ Plugins

 import GHC.Types.Unique.FM

 import GHC.Types.Unique.DFM

 import GHC.Cmm.Config (CmmConfig)

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Unit.Home.PackageTable

                   , 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

 import GHC.Utils.Misc

 import GHC.Unit.Home

 import GHC.Data.Maybe

 import Control.Applicative

 import System.Directory

 import GHC.Utils.Logger (Logger)

 import Control.Monad ((<$!>))

 import GHC.Unit.Home.Graph

 data LinkDepsOpts = LinkDepsOpts

   , ldLogger :: !Logger

   }

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

 --

    , rmDupLinkables

    , modifyLoaderState

    , initLinkDepsOpts

    )

 where

 import qualified Data.Set as Set

 import Data.Char (isSpace)

 import Data.Functor ((<&>))

 import Data.IORef

 import Data.List (intercalate, isPrefixOf, nub, partition)

 import Data.Maybe

 #endif

 import GHC.Utils.Exception

 -- Note [Linkers and loaders]

 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~

   -> IO (LoaderState, SuccessFlag, [Linkable], 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 = ldAllUnits deps

       EPS {eps_iface_bytecode} <- hscEPS hsc_env

       pure (lookupModuleEnv eps_iface_bytecode mod)

 {- **********************************************************************

         lazyPut bh warns

         lazyPut bh anns

         put_ bh decls

         put_ bh foreign_

         put_ bh insts

         put_ bh fam_insts

         warns       <- {-# SCC "bin_warns" #-} lazyGet bh

         anns        <- {-# SCC "bin_anns" #-} lazyGet bh

         decls       <- {-# SCC "bin_tycldecls" #-} get bh

         foreign_    <- get bh

         insts       <- {-# SCC "bin_insts" #-} get bh

         fam_insts   <- {-# SCC "bin_fam_insts" #-} get bh