import GHC.Unit.Env

 import GHC.Unit.Types

 import GHC.Unit.Module

 import GHC.Unit.Home

 import GHC.Unit.Home.Graph (UnitEnvGraph)

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Types.Unique.Set

 import qualified Data.List as L(sort)

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

 import qualified System.Directory as SD

 import qualified System.OsPath as OsPath

 import qualified Data.List.NonEmpty as NE

       dflags    = hsc_dflags hsc_env

       fopts     = initFinderOpts dflags

   in do

 findImportedModuleWithIsBoot :: HscEnv -> ModuleName -> IsBootInterface -> PkgQual -> IO FindResult

 findImportedModuleWithIsBoot hsc_env mod is_boot pkg_qual = do

   :: FinderCache

   -> FinderOpts

   -> UnitEnv

   -> Maybe HomeUnit

   -> ModuleName

   -> PkgQual

   -> IO FindResult

   case mb_pkg of

     NoPkgQual  -> unqual_import

     ThisPkg uid | (homeUnitId <$> mhome_unit) == Just uid -> home_import

                 | otherwise -> pprPanic "findImportModule" (ppr mod_name $$ ppr mb_pkg $$ ppr (homeUnitId <$> mhome_unit) $$ ppr uid $$ ppr (map fst all_opts))

     OtherPkg _ -> pkg_import

   where

     home_import = case mhome_unit of

                    Just home_unit -> findHomeModule fc fopts home_unit mod_name

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

       -- of that package which reexports it.

       | Just real_mod_name <- lookupUniqMap (finder_reexportedModules opts) mod_name =

       | elementOfUniqSet mod_name (finder_hiddenModules opts) =

         return (mkHomeHidden uid)

       | otherwise =

     -- Do not be smart and change this to `foldr orIfNotFound home_import hs` as

     -- that is not the same!! home_import is first because we need to look within ourselves

     -- first before looking at the packages in order.

     pkg_import    = findExposedPackageModule fc fopts units  mod_name mb_pkg

                     `orIfNotFound`

                     findExposedPackageModule fc fopts units mod_name NoPkgQual

                   Nothing -> ue_homeUnitState ue

 -- | Locate a plugin module requested by the user, for a compiler

 -- plugin.  This consults the same set of exposed packages as

    , mgLookupModule

    , mgLookupModuleName

    , mgHasHoles

    , showModMsg

     -- ** Reachability queries

 import GHC.Utils.Misc ( partitionWith )

 import System.FilePath

 import qualified Data.Map as Map

 import GHC.Types.Unique.DSet

 import GHC.Unit.Module

 import GHC.Unit.Module.ModNodeKey

 import GHC.Unit.Module.Stage

   -- Cached computation, whether any of the ModuleGraphNode are isHoleModule,

   -- This is only used for a hack in GHC.Iface.Load to do with backpack, please

   -- remove this at the earliest opportunity.

   }

 -- | Why do we ever need to construct empty graphs? Is it because of one shot mode?

 emptyMG :: ModuleGraph

 emptyMG = ModuleGraph [] (graphReachability emptyGraph, const Nothing)

                          (graphReachability emptyGraph, const Nothing)

                          (graphReachability emptyGraph, const Nothing)

                          False

 -- | Construct a module graph. This function should be the only entry point for

 -- building a 'ModuleGraph', since it is supposed to be built once and never modified.

   where

     duplicate_errs = rights (Map.elems node_types)

     node_types = Map.fromListWithKey go [ (mkNodeKey n, Left (moduleNodeType n)) | n <- mg_mss ]

       where

         -- Multiple nodes with the same key are not allowed.

 -- | Check that all dependencies in the graph are present in the node_types map.

 -- This is a helper function used by checkModuleGraph.

                             -> ModuleGraphNode

                             -> Maybe ModuleGraphInvariantError

 checkAllDependenciesInGraph node_types node =

 -- | Check if for the fixed module node invariant:

 --

 --   Fixed nodes can only depend on other fixed nodes.

                 -> ModuleGraphNode

                 -> Maybe ModuleGraphInvariantError

 checkFixedModuleInvariant node_types node = case node of

 -- To preserve invariants, 'f' can't change the isBoot status.

 mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph

 mapMG f mg@ModuleGraph{..} = mg

   }

 -- | Map a function 'f' over all the 'ModSummaries', in 'IO'.

 -- To preserve invariants, 'f' can't change the isBoot status.

 -- described in the export list haddocks.

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

   deriving (Functor, Traversable, Foldable)

 -- | Transitive dependencies, including SOURCE edges

     lookup_key :: ZeroScopeKey -> Maybe Int

     lookup_key = fmap zeroSummaryNodeKey . lookup_node

     node_map =

       Map.fromList [ (s, node)

                    | node <- nodes

     lookup_key ::  (NodeKey, ModuleStage) -> Maybe Int

     lookup_key = fmap stageSummaryNodeKey . lookup_node

     node_map =

       Map.fromList [ (s, node)

                    | node <- nodes

 extendMG :: ModuleGraph -> ModuleGraphNode -> ModuleGraph

 extendMG ModuleGraph{..} node =

   ModuleGraph

     , mg_has_holes = mg_has_holes || maybe False isHsigFile (moduleNodeInfoHscSource =<< mgNodeIsModule node)

     }