import GHC.Unit.Finder.Types

 import GHC.Data.FastString

 import GHC.Data.OsPath

 -- | Create a new 'FinderOpts' from DynFlags.

 initFinderOpts :: DynFlags -> FinderOpts

   , finder_workingDirectory = fmap unsafeEncodeUtf $ workingDirectory flags

   , finder_thisPackageName  = mkFastString <$> thisPackageName flags

   , finder_hiddenModules = hiddenModules flags

   , finder_hieDir = fmap unsafeEncodeUtf $ hieDir flags

   , finder_hieSuf = unsafeEncodeUtf $ hieSuf flags

   , finder_hiDir = fmap unsafeEncodeUtf $ hiDir flags

 import GHC.Foreign (withCString, peekCString)

 import qualified Data.Set as Set

 import qualified GHC.LanguageExtensions as LangExt

   -- Note [Filepaths and Multiple Home Units]

   workingDirectory      :: Maybe FilePath,

   thisPackageName       :: Maybe String, -- ^ What the package is called, use with multiple home units

   reexportedModules     :: [ReexportedModule],

   -- ways

         workingDirectory        = Nothing,

         thisPackageName         = Nothing,

         reexportedModules       = [],

         objectDir               = Nothing,

 import qualified Data.Map as Map

 import qualified Data.Set as Set

 import Control.Concurrent.MVar

 import Control.Monad

 import qualified Control.Monad.Catch as MC

 import Data.IORef

 import Data.Maybe

 import qualified Data.List as List

 import System.FilePath

   where

     diag_opts = initDiagOpts dflags

                   (filter (\ms -> ms_unitid ms == homeUnitId_ dflags)

                        (mgModSummaries mod_graph)))

     reexported_mods = reexportedModules dflags

     hidden_mods     = hiddenModules dflags

     lookupModule mn = findImportedModule hsc_env mn NoPkgQual

     final_msgs hidden_warns reexported_warns

           =

         unionManyMessages $

           ++ [warn (DriverUnknownReexportedModules (homeUnitId_ dflags) reexported_warns) | not (null reexported_warns)]

 -- | Describes which modules of the module graph need to be loaded.

 import qualified Data.List.NonEmpty as NE

 import qualified Data.Map as Map

 import qualified Data.Set as Set

 import Data.Word

 import System.FilePath

 import Text.ParserCombinators.ReadP hiding (char)

 addHiddenModule :: String -> DynP ()

 addHiddenModule p =

 addReexportedModule :: String -> DynP ()

 addReexportedModule p =

     moduleExport alias avails =

         DsiModExport (nubSortNE orig_names) (sortAvails (nubAvails avails))

       where

         aliasErr = error $ "mkDocStructureFromExportList: "

                            ++ (moduleNameString . moduleName) mdl

                            ++ ": Can't find alias " ++ moduleNameString alias

                     NonEmpty.toList

     -- Map from aliases to true module names.

     aliasMap =

           (this_mdl_name, this_mdl_name :| [])

           : (flip concatMap (M.toList imported) $ \(mdl, imvs) ->

               [(imv_name imv, moduleName mdl :| []) | imv <- imvs])

 import Control.Monad

 import Data.Time

 import qualified Data.Map as M

 import GHC.Driver.Env

 import GHC.Driver.Config.Finder

 import Data.List.NonEmpty ( NonEmpty (..) )

 import qualified System.OsPath as OsPath

 import qualified Data.List.NonEmpty as NE

     home_pkg_import (uid, opts)

       -- If the module is reexported, then look for it as if it was from the perspective

       -- of that package which reexports it.

         findImportedModuleNoHsc fc opts ue (Just $ DefiniteHomeUnit uid Nothing) real_mod_name NoPkgQual

         return (mkHomeHidden uid)

       | otherwise =

         findHomePackageModule fc opts uid mod_name

   pure (Linkable obj_time mod (NE.singleton (DotO obj_fn ModuleObject)))

   -- We used to look for _stub.o files here, but that was a bug (#706)

   -- Now GHC merges the stub.o into the main .o (#3687)

 import GHC.Unit

 import GHC.Data.OsPath

 import qualified Data.Map as M

 import GHC.Fingerprint

 import GHC.Platform.Ways

 import GHC.Unit.Env

 import GHC.Data.FastString

 -- | The 'FinderCache' maps modules to the result of

 -- searching for that module. It records the results of searching for

       -- that have a similar name.

   , finder_workingDirectory :: Maybe OsPath

   , finder_thisPackageName  :: Maybe FastString

   , finder_hieDir :: Maybe OsPath

   , finder_hieSuf :: OsString

   , finder_hiDir :: Maybe OsPath