import Data.IORef

 import qualified Data.Set as Set

 runHsc :: HscEnv -> Hsc a -> IO a

 runHsc hsc_env hsc = do

   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, fields) <-

      unzip3 . concat <$>

        hugSomeThingsBelowUs (\mod_info ->

                                   let details = hm_details mod_info

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

                           mnwib

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

 --

      cmp_fam_inst = comparing (nameOccName . ifFamInstTcName)

      cmp_fields :: IfaceFieldInst -> IfaceFieldInst -> Ordering

         lexicalCompareFieldLabel (flLabel fld1) (flLabel fld2)

      dflags = hsc_dflags hsc_env

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

 fieldinstToIfaceFieldInst :: FieldInst -> IfaceFieldInst

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

 coreRuleToIfaceRule :: CoreRule -> IfaceRule

 -}

 tcIfaceField :: IfaceFieldInst -> IfL FieldInst -- Improve pretty printing

 {-

 ************************************************************************

 import Data.Functor

 import Data.Maybe

 import qualified Data.List as List

 import {-# SOURCE #-} GHC.Tc.TyCl.Utils 

   (mkSetFieldBinds, mkRecordSetterType, mkRecordModifierType)

        ; case lookupFieldLabel fam_inst_envs rdr_env tys of

             Just (tc, fl, gre, r_ty, a_ty) ->

                 do { let sel_name = flSelector fl

                    ; (tv_prs, preds, setter_ty, modifier_ty) 

                         <- tc_inst_setfield_binds setter_id modifier_id

      -- See (HF1) in Note [HasField instances]

      try_user_instances = matchInstEnv dflags short_cut clas tys

      lookupSetFieldBinds fl tycon = do

         tcg_env <- getGblEnv

         let 

           gbl_flds = tcg_fld_inst_env tcg_env

           req_flds = tcg_requested_fields tcg_env

           Just binds -> pure binds

           Nothing -> do 

             reqs <- readTcRef req_flds

             case List.lookup fl reqs of 

               Nothing -> do

                 updTcRef req_flds ((fl, binds) : )

      tc_inst_setfield_binds setter_id modifier_id

         | null tyvars   -- There may be overloading despite no type variables;

 import Data.Traversable ( for )

 import Data.IORef( newIORef )

 import GHC.Tc.TyCl.Utils (tcRecSetterBinds)

               tcg_rn_imports   = rn_imports,

               tcg_default      = foldMap subsume tc_defaults,

               tcg_inst_env     = tcg_inst_env gbl `unionInstEnv` home_insts,

               tcg_fam_inst_env = unionFamInstEnv (tcg_fam_inst_env gbl) home_fam_inst_env

             }) $ do {

 import Language.Haskell.Syntax.Basic (FieldLabelString(..))

 import Control.Monad

 {-

 ************************************************************************

   flds <- readTcRef req_flds

   tcg_env <- tcRecSelBinds (get_ids_to_check flds)

   writeTcRef req_flds []

   pure (tcg_env {

       })

   where

 mkSetFieldBinds tycon fl =

   collectFieldLabelInfo all_cons idDetails fl FieldSelectors $ \_ _ -> mk_binds

   where

       in fl { flSelector = flSelector fl `setNameUnique` uniq `tidyNameOcc` newOcc }

     mk_binds cons_w_field rec_details ty_builder = do

 mkRecordSetterBind :: FieldLabel -> RecordBindBuilder (Id, LHsBind GhcRn)

 mkRecordSetterBind origFl fl = mk_record_bind 2 err_expr mkRecordSetterType mk_match fl where

 module GHC.Tc.TyCl.Utils where

 import GHC.Core.TyCon (TyCon)

 import GHC.Tc.Utils.Monad (TcM)

 import GHC.Types.Var (Id)

 import Language.Haskell.Syntax.Binds (LHsBind)

 import GHC.Hs.Extension (GhcRn)

 import GHC.Core.Type (Type)

 mkRecordSetterType :: Type -> Type -> Type

 import Data.Map ( Map )

 import Data.Typeable ( TypeRep )

 import Data.Maybe    ( mapMaybe )

 -- | The import specification as written by the user, including

 -- the list of explicitly imported names. Used in 'ModIface' to

           -- they all have a non-empty gre_imp field.

         tcg_keep      :: TcRef NameSet,

         tcg_th_used :: TcRef Bool,

           -- ^ @True@ \<=> Template Haskell syntax used.

         -- ^ See Note [Generating fresh names for FFI wrappers]

     }

 -- NB: topModIdentity, not topModSemantic!

 -- Definition sites of orphan identities will be identity modules, not semantic

 -- modules.

 import qualified Data.Map as Map

 import GHC.Core.Coercion (isReflCo)

 {-

                 tcg_type_env_var   = type_env_var,

                 tcg_inst_env       = emptyInstEnv,

                 tcg_fam_inst_env   = emptyFamInstEnv,

                 tcg_ann_env        = emptyAnnEnv,

                 tcg_complete_match_env = [],

                 tcg_th_used        = th_var,

 {-# LANGUAGE FlexibleContexts   #-}

 {-# LANGUAGE UndecidableInstances #-}

 {-# OPTIONS_GHC -Wno-orphans #-} -- Outputable FieldLabelString

 {-

 %

    , DuplicateRecordFields(..)

    , FieldSelectors(..)

    , flIsOverloaded

    )

 where

                                                 <> ppr (flHasDuplicateRecordFields fl)

                                                 <> ppr (flHasFieldSelector fl))

 instance Outputable FieldLabelString where

   ppr (FieldLabelString l) = ppr l

 flIsOverloaded fl =

  flHasDuplicateRecordFields fl == DuplicateRecordFields

  || flHasFieldSelector fl == NoFieldSelectors

 -- from it

 --       sel_i t1..tk (D t1..tk op1 ... opm) = opi

 --

   | (dict_arg : _) <- drop n_ty_args args

   | otherwise

   = Nothing

 {-

 ************************************************************************

 import GHC.Core         ( CoreRule )

 import GHC.Core.FamInstEnv

 import GHC.Core.InstEnv ( InstEnv, emptyInstEnv )

 import GHC.Types.Avail

 import GHC.Types.CompleteMatch

 import GHC.Types.DefaultEnv

 import GHC.Types.TypeEnv

 import GHC.Types.Annotations ( Annotation )

 import GHC.Types.FieldLabel

 -- | The 'ModDetails' is essentially a cache for information in the 'ModIface'

 -- for home modules only. Information relating to packages will be loaded into

       -- ^ Complete match pragmas for this module

    }

 -- | Constructs an empty ModDetails

 emptyModDetails :: ModDetails

 import Control.DeepSeq

 import Control.Exception

 {- Note [Interface file stages]

    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~

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

 }

 mkIfacePublic :: [IfaceExport]

                   -> [IfaceDeclExts 'ModIfaceFinal]

         GHC.Core.ConLike

         GHC.Core.DataCon

         GHC.Core.FamInstEnv

         GHC.Core.FVs

         GHC.Core.InstEnv

         GHC.Core.Lint