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

       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

     current_unit_id = homeUnitId <$> mhome_unit

     all_opts = case current_unit_id of

                 Nothing -> other_fopts

       -- 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 =

                   Just home_unit_id -> HUG.homeUnitEnv_units $ ue_findHomeUnitEnv home_unit_id ue

     hpt_deps :: Set.Set UnitId

     hpt_deps = homeUnitDepends units

     known_other_uids =

       let providers = maybe dep_providers (\u -> Set.delete u dep_providers) current_unit_id

       in Set.toList providers

     unknown_units =

           excluded = maybe dep_providers (\u -> Set.insert u dep_providers) current_unit_id

       in Set.toList (Set.difference candidates excluded)

     other_home_uids = known_other_uids ++ unknown_units

    , mgLookupModule

    , mgLookupModuleName

    , mgHasHoles

    , showModMsg

     -- ** Reachability queries

   -- 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.

     -- ^ For each module name, which home unit UnitIds define it together with the set of units for which the listing is complete.

   }

         = Map.fromListWith Set.union $

           [

               (moduleName, Set.singleton unitID) |

                   let unitID     = moduleNodeInfoUnitId moduleNodeInfo

           ]

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

 emptyMG :: ModuleGraph

                          (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.

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

 mapMG f mg@ModuleGraph{..} = mg

   { mg_mss = new_mss

   }

   where

     new_mss =

     , mg_loop_graph = mkTransLoopDeps new_mss

     , mg_zero_graph = mkTransZeroDeps new_mss

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

     }

   where

     new_mss = node : mg_mss