, hugInstancesBelow

    , hugAnnsBelow

    , hugCompleteSigsBelow

     -- * Legacy API

    , hscUpdateHPT

 hugAnnsBelow hsc uid mn = foldr (flip extendAnnEnvList) emptyAnnEnv <$>

   hugSomeThingsBelowUs (md_anns . hm_details) False hsc uid mn

 -- | Find all COMPLETE pragmas in modules that are in the transitive closure of the

 -- given module.

 hugCompleteSigsBelow :: HscEnv -> UnitId -> ModuleNameWithIsBoot -> IO CompleteMatches

   hugSomeThingsBelowUs (md_complete_matches . hm_details) False hsc uid mn

 -- | Find instances visible from the given set of imports

 hugInstancesBelow hsc_env uid mnwib = do

  let mn = gwib_mod mnwib

  (insts, famInsts) <-

                                   -- Don't include instances for the current module

                                   in if moduleName (mi_module (hm_iface mod_info)) == mn

                                        then []

                           True -- Include -hi-boot

                           hsc_env

                           uid

 -- | Get things from modules in the transitive closure of the given module.

 --

 -- Note: Don't expose this function. This is a footgun if exposed!

 -- An explicit check to see if we are in one-shot mode to avoid poking the ModuleGraph thunk

 -- These things are currently stored in the EPS for home packages. (See #25795 for

 -- progress in removing these kind of checks)

 -- See Note [Downsweep and the ModuleGraph]

   = let hug = hsc_HUG hsc_env

         mg  = hsc_mod_graph hsc_env

     in

     sequence

     [ things

       -- "Finding each non-hi-boot module below me" maybe could be cached (well,

         -- Look it up in the HUG

     , let things = lookupHug hug mod_uid mod >>= \case

           msg = vcat [text "missing module" <+> ppr mod,

                      text "When starting from"  <+> ppr mn,

                      text "below:" <+> ppr (moduleGraphModulesBelow mg uid mn),

                         -- This really shouldn't happen, but see #962

     ]

 -- | Deal with gathering annotations in from all possible places

 --   and combining them into a single 'AnnEnv'

 prepareAnnotations :: HscEnv -> Maybe ModGuts -> IO AnnEnv

 import GHC.Core.TyCo.FVs

 import GHC.Iface.Load

 import GHC.Tc.Errors.Types

 import GHC.Tc.Types.Evidence

 -- We don't need to check the current module, this is done in

 -- tcExtendLocalFamInstEnv.

 -- See Note [The type family instance consistency story].

   = do { (eps, hug) <- getEpsAndHug

        ; traceTc "checkFamInstConsistency" (ppr directlyImpMods)

        ; let { -- Fetch the iface of a given module.  Must succeed as

              -- See Note [Order of type family consistency checks]

              }

        ; debug_consistent_set <- mapM (\x -> (\y -> (x, length y)) <$> modConsistent x) directlyImpMods

        ; traceTc "init_consistent_set" (ppr debug_consistent_set)

        ; let init_consistent_set = map fst (reverse (sortOn snd debug_consistent_set))

 import GHC.Core.TyCo.Tidy( tidyTopType )

 import GHC.Core.FamInstEnv

    ( FamInst, pprFamInst, famInstsRepTyCons, orphNamesOfFamInst

 import GHC.Parser.Header       ( mkPrelImports )

   = do  { (rn_imports, imp_user_spec, rdr_env, imports) <- rnImports import_decls

         -- Get the default declarations for the classes imported by this module

         -- and group them by class.

         ; this_mod <- getModule

         ; gbl_env <- getGblEnv

         ; let unitId = homeUnitId $ hsc_home_unit hsc_env

                 -- filtering also ensures that we don't see instances from

                 -- modules batch (@--make@) compiled before this one, but

                 -- which are not below this one.

                     hugInstancesBelow hsc_env unitId mnwib

                 -- We use 'unsafeInterleaveIO' to avoid redundant memory allocations

                 -- See Note [Lazily loading COMPLETE pragmas] from GHC.HsToCore.Monad

               tcg_rn_imports   = rn_imports,

               tcg_default      = foldMap subsume tc_defaults,

               tcg_inst_env     = tcg_inst_env gbl `unionInstEnv` home_insts,

             }) $ do {

         ; traceRn "rn1" (ppr (imp_direct_dep_mods imports))

                              $ imports }

         ; logger <- getLogger

         ; withTiming logger (text "ConsistencyCheck"<+>brackets (ppr this_mod)) (const ())

         ; traceRn "rn1: } checking family instance consistency" empty

         ; gbl_env <- getGblEnv