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

    , IfaceAbiHashes (..)

    , IfaceSelfRecomp (..)

    , IfaceCache (..)

    , IfaceSimplifiedCore (..)

    , withSelfRecomp

    , IfaceExport

    , IfacePublic_(..)

    , IfacePublic

    , PartialIfacePublic

    , IfaceModInfo(..)

    , WhetherHasOrphans

    , WhetherHasFamInst

 type PartialModIface = ModIface_ 'ModIfaceCore

 type ModIface = ModIface_ 'ModIfaceFinal

 type PartialIfacePublic = IfacePublic_ 'ModIfaceCore

 type IfacePublic = IfacePublic_ 'ModIfaceFinal

 -- | Extends a PartialModIface with hashes of the ABI.

 --

 data ModIfacePhase

   = ModIfaceCore

   | ModIfaceFinal

 -- | In-memory byte array representation of a 'ModIface'.

 --

   -- See Note [Private fields in ModIface] for when this fields needs to be cleared

   -- (e.g., set to 'Nothing').

   FullIfaceBinHandle :: !(Strict.Maybe FullBinData) -> IfaceBinHandle 'ModIfaceFinal

 withSelfRecomp iface nk jk =

   case mi_self_recomp_info iface of

     Nothing -> nk

                 -- importing this module. The main, original part of an interface.

                 -- ^ Information needed for checking self-recompilation.

                 -- See Note [Self recompilation information in interface files]

                 -- ^ The part of the interface written when `-fwrite-if-simplified-core` is enabled.

                 -- These parts are used to restart bytecode generation.

                 -- defined by the user).  Used for GHCi and for inspecting

                 -- the contents of modules via the GHC API only.

                 -- ^ Additional optional fields, where the Map key represents

                 -- the field name, resulting in a (size, serialized data) pair.

                 -- Because the data is intended to be serialized through the

                 -- ^ Warnings

                 -- NOT STRICT!  we read this field lazily from the interface file

                 -- ^ Annotations

                 -- NOT STRICT!  we read this field lazily from the interface file

                 -- ^ Type, class and variable declarations

                 -- The hash of an Id changes if its fixity or deprecations change

                 --      (as well as its type of course)

                 -- the hash of the parent class/tycon changes

                 -- ^ default declarations exported by the module

                 -- Instance declarations and rules

         mi_trust_     :: IfaceTrustInfo,

                 -- itself) but imports some trustworthy modules from its own

                 -- package (which does require its own package be trusted).

                 -- See Note [Trust Own Package] in GHC.Rename.Names

                 -- ^ {-# COMPLETE #-} declarations

         mi_caches_ :: IfaceCache,

                 -- ^ Cached lookups of some parts of mi_public

                 -- ^ Either `()` or `IfaceAbiHashes` for

                 -- a fully instantiated interface.

                 -- These fields are hashes of different parts of the public interface.

 }

 mkIfacePublic :: [IfaceExport]

                   -> [(OccName, Fixity)]

                   -> IfaceWarnings

                   -> [IfaceAnnotation]

 forceModIface.

 -}

 mi_flag_hash = fmap mi_sr_flag_hash . mi_self_recomp_

 mi_opt_hash = fmap mi_sr_opt_hash . mi_self_recomp_

 mi_hpc_hash = fmap mi_sr_hpc_hash . mi_self_recomp_

 mi_src_hash = fmap mi_sr_src_hash . mi_self_recomp_

 mi_usages = fmap mi_sr_usages . mi_self_recomp_

 mi_plugin_hash = fmap mi_sr_plugin_hash . mi_self_recomp_

 -- | Accessor for the module hash of the ABI from a ModIface.

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

 -- file.

 mi_boot iface = if mi_hsc_src iface == HsBootFile