-- part of the compiler.

       lookupIfaceByModuleHsc hsc_env (mnkToModule key) >>= \case

         Just iface -> return (M.Succeeded iface)

     case read_result of

       M.Succeeded iface -> do

         -- Computer information about this node

         :: HomeUnitGraph

         -> PackageIfaceTable

         -> Module

 lookupIfaceByModule hug pit mod

   = HUG.lookupHugByModule mod hug >>= pure . \case

        Nothing -> lookupModuleEnv pit mod

    -- If the module does come from the home package, why do we look in the PIT as well?

    -- (a) In OneShot mode, even home-package modules accumulate in the PIT

    -- We could eliminate (b) if we wanted, by making GHC.Prim belong to a package

    -- of its own, but it doesn't seem worth the bother.

 lookupIfaceByModuleHsc hsc_env mod = do

   eps <- hscEPS hsc_env

   lookupIfaceByModule (hsc_HUG hsc_env) (eps_PIT eps) mod

 hscIsGHCiMonad hsc_env name

   = runHsc hsc_env $ ioMsgMaybe $ hoistTcRnMessage $ isGHCiMonad hsc_env name

 hscGetModuleInterface hsc_env0 mod = runInteractiveHsc hsc_env0 $ do

   hsc_env <- getHscEnv

   ioMsgMaybe $ hoistTcRnMessage $ getModuleInterface hsc_env mod

             _ | isHomeModule home_unit mod      -> True

             _ -> isUnitTrusted unit_state (moduleUnit m)

     lookup' m = do

         hsc_env <- getHscEnv

         iface <- liftIO $ lookupIfaceByModuleHsc hsc_env m

             _ | isHomeModule home_unit mod      -> True

             _ -> isUnitTrusted unit_state (moduleUnit m)

     lookup' m = do

         hsc_env <- getHscEnv

         iface <- liftIO $ lookupIfaceByModuleHsc hsc_env m

 data LoadedPlugin = LoadedPlugin

   { lpPlugin :: PluginWithArgs

   -- ^ the actual plugin together with its commandline arguments

   -- ^ the module containing the plugin

   }

         minf_type_env  :: TypeEnv,

         minf_exports   :: [AvailInfo],

         minf_instances :: [ClsInst],

         minf_safe      :: SafeHaskellMode,

         minf_modBreaks :: Maybe InternalModBreaks

   }

     Nothing  -> return Nothing

     Just hmi -> do

       let details  = hm_details hmi

       return (Just (ModuleInfo {

                         minf_type_env  = md_types details,

                         minf_exports   = md_exports details,

      Just tyThing -> return (Just tyThing)

      Nothing      -> liftIO (lookupType hsc_env name)

 modInfoIface = minf_iface

 -- | Retrieve module safe haskell mode

     --  a) we used something from it; has something in used_names

     --  b) we imported it, even if we used nothing from it

     --     (need to recompile if its export list changes: export_fprint)

     mkUsage mod iface

       | toUnitId (moduleUnit mod) `Set.notMember` home_unit_ids

       = Just $ UsagePackageModule{ usg_mod      = mod,

                       usg_entities = Map.toList ent_hashs,

                       usg_safe     = imp_safe }

       where

         hash_env   = mi_hash_fn iface

         imported_exports

           = if not depend_on_exports

             then Nothing

               Just $

                 HomeModImport

                  { hmiu_orphanLikeHash

                  , hmiu_importedAvails

                  }

         by_is_safe (ImportedByUser imv) = imv_is_safe imv

     known_key_maps :: Module -> IfM lcl KnownKeyNameMaps

     known_key_maps mod

       = do { iface <- loadInterfaceWithException doc mod ImportBySystem

            ; eps <- getEps

            ; case lookupModuleEnv (eps_known_keys eps) mod of

                Just (cached_hash, kk_maps)

                                      (abi_hash, kk_maps) }

                        ; return kk_maps } }

     build_maps iface = (kk_map, occ_map)

       where

         kk_map :: UniqFM KnownKey Name

                  -> ModuleName

                  -> IsBootInterface     -- {-# SOURCE #-} ?

                  -> PkgQual             -- "package", if any

 loadSrcInterface doc scope mod want_boot maybe_pkg

   = do { res <- loadSrcInterface_maybe doc scope mod want_boot maybe_pkg

                        -> ModuleName

                        -> IsBootInterface     -- {-# SOURCE #-} ?

                        -> PkgQual             -- "package", if any

 loadSrcInterface_maybe doc scope mod want_boot maybe_pkg

   -- We must first find which Module this import refers to.  This involves

 -- rare operation, but in particular it is used to load orphan modules

 -- in order to pull their instances into the global package table and to

 -- handle some operations in GHCi).

 loadModuleInterface doc mod = initIfaceTcRn (loadSysInterface doc mod)

 -- | Load interfaces for a collection of modules.

 -- | Loads the interface for a given Name.

 -- Should only be called for an imported name;

 -- otherwise loadSysInterface may not find the interface

 loadInterfaceForName doc name

   = do { when debugIsOn $  -- Check pre-condition

          do { this_mod <- getModule

         initIfaceTcRn $ loadSysInterface doc (nameModule name) }

 -- | Loads the interface for a given Module.

 loadInterfaceForModule doc m

   = do

     -- Should not be called with this module

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

 -- | Loads a system interface and throws an exception if it fails

 loadSysInterface doc mod_name = loadInterfaceWithException doc mod_name ImportBySystem

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

 -- | Loads a user interface and throws an exception if it fails. The first parameter indicates

 -- whether we should import the boot variant of the module

 loadUserInterface is_boot doc mod_name

   = loadInterfaceWithException doc mod_name (ImportByUser is_boot)

 loadPluginInterface doc mod_name

   = loadInterfaceWithException doc mod_name ImportByPlugin

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

 -- | A wrapper for 'loadInterface' that throws an exception if it fails

 loadInterfaceWithException doc mod_name where_from

   = do

     dflags <- getDynFlags

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

 loadInterface :: SDoc -> Module -> WhereFrom

 -- loadInterface looks in both the HPT and PIT for the required interface

 -- If not found, it loads it, and puts it in the PIT (always).

                              liftIO $ computeInterface hsc_env doc_str hi_boot_file mod

         ; case read_result of {

             Failed err -> do

                 ; updateEps_ $ \eps ->

                         eps { eps_PIT = extendModuleEnv (eps_PIT eps) (mi_module fake_iface) fake_iface }

         ; new_eps_complete_matches <- tcIfaceCompleteMatches (mi_complete_matches iface)

         ; purged_hsc_env <- getTopEnv

                           && isJust (lookupKnotVars (if_rec_types gbl_env) mod)

                             -- Warn against an EPS-updating import

                             -- of one's own boot file! (one-shot only)

                 then eps { eps_PTE = addDeclsToPTE (eps_PTE eps) new_eps_decls }

            else

                 eps {

                   eps_PTE          = addDeclsToPTE   (eps_PTE eps) new_eps_decls,

                   eps_iface_bytecode = add_bytecode (eps_iface_bytecode eps),

                   eps_rule_base    = extendRuleBaseList (eps_rule_base eps)

                   eps_defaults    =  extendModuleEnv (eps_defaults eps) mod new_eps_defaults

                                                    }

     }}}}

 {- Note [Loading your own hi-boot file]

 import GHC.Unit.Module (Module)

 import GHC.Tc.Utils.Monad (IfM)

 import GHC.Utils.Outputable (SDoc)

         return $ needsRecompileBecause $ ModulePackageChanged new_name

              -> IfG RecompileRequired

 needInterface mod continue

   = do

         Nothing -> return $ NeedsRecompile MustCompile

         Just mbc -> liftIO $ continue mbc

 tryGetModIface doc_msg mod

   = do  -- Load the imported interface if possible

     logger <- getLogger

   logger <- getLogger

   needInterface mod $ \iface -> do

     let reason = ModuleChanged (moduleName mod)

         -- We only track the ABI hash of package modules, rather than

         -- individual entity usages, so if the ABI hash changes we must

         -- recompile.  This is safe but may entail more recompilation when

   logger <- getLogger

   needInterface mod $ \iface -> do

     let reason = ModuleChangedRaw (moduleName mod)

 checkModUsage _  UsageHomeModuleBytecode{ usg_mod_name = mod_name

                                                  , usg_unit_id = uid

                                                  , usg_bytecode_hash = old_bytecode_hash } = do

     logger <- getLogger

     needInterface mod $ \iface -> do

      let

          new_decl_hash   = mi_hash_fn  iface

          reason = ModuleChanged (moduleName mod)

 -- Does this require recompilation?

 --

 -- See Note [When to recompile when export lists change?]

 checkHomeModImport _ _ Nothing _ = return UpToDate

 checkHomeModImport logger reason

   (Just (HomeModImport old_orphan_like_hash old_avails))

                       2 (ppr changes)

                  return $ needsRecompileBecause reason

   where

     new_exports          = mi_exports iface

 -- | The exported avails of a module have changed. Should this cause recompilation

     get_orph_hash mod = do

           iface <- initIfaceLoad hsc_env . withIfaceErr ctx

                             $ loadInterface (text "getOrphanHashes") mod ImportBySystem

   mapM get_orph_hash mods

 -- interface, but without 'imp_mods'.

 calculateAvails :: HomeUnit

                 -> S.Set UnitId

                 -> IsSafeImport

                 -> IsBootInterface

                 -> ImportedBy

 calculateAvails home_unit other_home_units iface mod_safe' want_boot imported_by =

   let imp_mod    = mi_module iface

       imp_sem_mod= mi_semantic_module iface

       deps       = mi_deps iface

       trust      = getSafeMode $ mi_trust iface

       trust_pkg  = mi_trust_pkg iface

 gresFromAvails :: HscEnv -> Maybe ImportSpec -> [AvailInfo] -> [GlobalRdrElt]

 gresFromAvails hsc_env prov = concatMap (gresFromAvail hsc_env prov)

 importsFromIface hsc_env iface decl_spec hidden = mkGlobalRdrEnv $ case hidden of

     Nothing -> all_gres

     Just hidden_names -> filter (not . (`elemNameSet` hidden_names) . greName) all_gres

 filterImports

     :: HasDebugCallStack

     => HscEnv

     -> ImpDeclSpec

          -- ^ Import spec

     -> Maybe (ImportListInterpretation, [LIE GhcPs])

       where

         doc = text "Compute minimal imports for" <+> ppr decl

     -- The main trick here is that if we're importing all the constructors

     -- we want to say "T(..)", but if we're importing only a subset we want

     -- to say "T(A,B,C)".  So we have to find out what the module exports.

 -}

 badImportItemErr

   -> IsSubordinateError

   -> [AvailInfo]

   -> TcRn (NonEmpty ImportLookupReason)

     definedMod = moduleName $ assertPpr (isExternalName name) (ppr name) (nameModule name)

     doc = text "The name" <+> quotes (ppr occ) <+> text "is mentioned explicitly"

 lookupImpDeclDeprec iface gre

   -- Bleat if the thing, or its parent, is warn'd

   = mi_decl_warn_fn iface (greOccName gre) `mplus`

     -> throwIO (InstallationError "Plugins require -fno-external-interpreter")

   _ -> pure ()

 loadPlugin' occ_name plugin_name hsc_env mod_name

   = do { let plugin_rdr_name = mkRdrQual mod_name occ_name

              dflags = hsc_dflags hsc_env

 -- Need the module as well to record information in the interface file

 lookupRdrNameInModuleForPlugins :: HasDebugCallStack

                                 => HscEnv -> ModuleName -> RdrName

 lookupRdrNameInModuleForPlugins hsc_env mod_name rdr_name = do

     let dflags     = hsc_dflags hsc_env

     -- First find the unit the module resides in by searching exposed units and home modules

 pprImportLookup = \case

   ImportLookupBad k iface decl_spec ie _exts ->

     let

       pprImpDeclSpec iface decl_spec =

         quotes (ppr (moduleName $ is_mod decl_spec)) <+> case mi_boot iface of

             IsBoot  -> text "(hi-boot interface)"

 import GHC.Unit.Types (Module)

 import GHC.Unit.State (UnitState)

 import GHC.Utils.Outputable

       T9006, T11071, T9905fail2, T5385, T10668

   -}

   ImportLookupBad :: BadImportKind

                   -> ImpDeclSpec

                   -> IE GhcPs

                   -> ImportLookupExtensions

         _ -> pure Nothing

 -- | Returns the module a Name belongs to, if it is isn't local.

 getExternalModIface nm = do

   isLocal <- nameIsLocalOrFrom <$> getModule <*> pure nm

   if isLocal

                  ifc <- modIface mod

                  deps <- dep_finsts . mi_deps <$> modIface mod

                  pure $

                       then mod:deps

                       else deps

 -- a package module with an interface on disk.  If neither of these is

 -- true, then the result will be an error indicating the interface

 -- could not be found.

 getModuleInterface hsc_env mod

   = runTcInteractive NoTcMPlugins hsc_env $

     loadModuleInterface (text "getModuleInterface") mod

 type PackageCompleteMatches  = CompleteMatches

 -- | Helps us find information about modules in the imported packages

         -- Domain = modules in the imported packages

 -- | Constructs an empty PackageIfaceTable

 {-# LANGUAGE UndecidableInstances #-}

 {-# LANGUAGE PatternSynonyms #-}

 {-# LANGUAGE DeriveAnyClass #-}

 module GHC.Unit.Module.ModIface

    ( ModIface

    , set_mi_fix_fn

    , set_mi_hash_fn

    , completePartialModIface

    , IfaceBinHandle(..)

    , PartialModIface

    , RetainedModIface

    , IfaceAnnotationsData

    , IfaceDeclsData

    , IfaceDefaultsData

    , IfaceRulesData

    , IfaceCompleteMatchesData

    , IfaceAbiHashesData

 type family IfaceDeclsData (phase :: ModIfacePhase) where

   IfaceDeclsData 'ModIfaceCore     = [IfaceDecl]

   IfaceDeclsData 'ModIfaceFinal    = [(Fingerprint, IfaceDecl)]

 type family IfaceDefaultsData (phase :: ModIfacePhase) where

   IfaceDefaultsData 'ModIfaceCore     = [IfaceDefault]

   IfaceDefaultsData 'ModIfaceFinal    = [IfaceDefault]

   IfaceDefaultsData 'ModIfaceRetained = ()

 type family IfaceRulesData (phase :: ModIfacePhase) where

   IfaceRulesData 'ModIfaceCore     = [IfaceRule]

   IfaceRulesData 'ModIfaceFinal    = [IfaceRule]

                 -- Instance declarations and rules

         mi_trust_     :: IfaceTrustInfo,

 -- | Old-style accessor for whether or not the ModIface came from an hs-boot

 -- file.

 mi_boot iface = if mi_hsc_src iface == HsBootFile

     then IsBoot

     else NotBoot

 -- | Lookups up a (possibly cached) fixity from a 'ModIface'. If one cannot be

 -- found, 'defaultFixity' is returned instead.

 mi_fix iface name = mi_fix_fn iface name `orElse` defaultFixity

 -- | The semantic module for this interface; e.g., if it's a interface

 -- | The "precise" free holes, e.g., the signatures that this

 -- 'ModIface' depends on.

 mi_free_holes iface =

   case getModuleInstantiation (mi_module iface) of

     (_, Just indef)

 emptyPublicModIface :: IfaceAnnotationsData phase

                     -> IfaceDeclsData phase

                     -> IfaceDefaultsData phase

                     -> IfaceRulesData phase

                     -> IfaceCompleteMatchesData phase

                     -> IfaceAbiHashesData phase

          , NFData (IfaceAnnotationsData phase)

          , NFData (IfaceDeclsData phase)

          , NFData (IfaceDefaultsData phase)

          , NFData (IfaceRulesData phase)

          , NFData (IfaceCompleteMatchesData phase)

          , NFData (IfaceAbiHashesData phase)

 instance ( NFData (IfaceAnnotationsData phase)

          , NFData (IfaceDeclsData phase)

          , NFData (IfaceDefaultsData phase)

          , NFData (IfaceRulesData phase)

          , NFData (IfaceCompleteMatchesData phase)

          , NFData (IfaceAbiHashesData phase)

   , mi_hi_bytes_ = FullIfaceBinHandle Strict.Nothing

   , mi_iface_hash_ = iface_hash

   }

 -- | Given a 'PartialIfacePublic', turn it into an 'IfacePublic' by completing

 -- missing fields.

   , mi_caches_ = cache

   }

 set_mi_mod_info :: IfaceModInfo -> ModIface_ phase -> ModIface_ phase

 set_mi_mod_info val iface = clear_mi_hi_bytes $ iface { mi_mod_info_ = val }

 set_mi_anns :: IfaceAnnotationsData phase -> ModIface_ phase -> ModIface_ phase

 set_mi_anns val = set_mi_public (\iface -> iface { mi_anns_ = val })

 set_mi_insts val = set_mi_public (\iface -> iface { mi_insts_ = val })

 set_mi_fam_insts val = set_mi_public (\iface -> iface { mi_fam_insts_ = val })

 set_mi_rules :: IfaceRulesData phase -> ModIface_ phase -> ModIface_ phase

   -> IfaceSimplifiedCoreData phase

   -> IfaceDefaultsData phase

   -> IfaceTopEnv

   -> IfaceRulesData phase

   -> IfaceTrustInfo

   -> Bool

   put_ bh hiVersion

     -- package hashes change when the compiler version changes (for now)

     -- see #5328

   f <- fingerprintBinMem bh

   putStrLn (showPpr dflags f)

 import GHC.Unit.Home.PackageTable

 import GHC.Unit.Module.Graph (ModuleGraphNode (..), ModuleNodeInfo(..))

 import GHC.Unit.Module.ModDetails

 import GHC.Unit.Module.ModSummary (isBootSummary)

 import GHC.Utils.Outputable (Outputable, (<+>), pprModuleName, text)

 import GHC.Utils.Error (withTiming)

 dropErr (Succeeded a) = Just a

 dropErr (Failed _) = Nothing

 loadHiFile hsc_env doc theModule = initIfaceLoad hsc_env $ do

   mod_iface <- loadSysInterface doc theModule

       let cls_insts = instEnvElts . md_insts $ hm_details hmi

           fam_insts = md_fam_insts $ hm_details hmi

   !interface <- do

     logger <- getLogger

   => [Flag]

   -> UnitState

   -> ModSummary

   -> IfaceMap

   -> InstIfaceMap

   -> ([ClsInst], [FamInst])

   -> UnitState

   -> DynFlags

   -> FilePath

   -> IfaceMap

   -> InstIfaceMap

   -> ([ClsInst], [FamInst])

     def_meths_env = mkOccEnv def_meths

     def_meths =

       [ (nameOccName nm, nm)

       , let occ = nameOccName nm

       , isDefaultMethodOcc occ

       ]