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

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

   -- * Very important queries

   , allInstances

   , allAnns

   , allCompleteSigs

   go hue = liftA2 (\(a,b) (a',b') -> (a `unionInstEnv` a', b ++ b'))

                   (hptAllInstances (homeUnitEnv_hpt hue))

 allAnns :: HomeUnitGraph -> IO AnnEnv

 allAnns hug = foldr go (pure emptyAnnEnv) hug where

   go hue = liftA2 plusAnnEnv (hptAllAnnotations (homeUnitEnv_hpt hue))

     -- * Queries about home modules

   , hptCompleteSigs

   , hptAllInstances

   , hptAllAnnotations

     -- ** More Traversal-based queries

   let (insts, famInsts) = unzip hits

   return (foldl' unionInstEnv emptyInstEnv insts, concat famInsts)

 -- | All annotations from the HPT

 hptAllAnnotations :: HomePackageTable -> IO AnnEnv

 hptAllAnnotations = fmap mkAnnEnv . concatHpt (md_anns . hm_details)