GHC.Utils.Touch.touch hie_file

     else

         -- See Note [Strictness in ModIface]

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

 -- NoRecomp handlers

         , vcat (map pprUsage (mi_usages iface))

         , vcat (map pprIfaceAnnotation (mi_anns iface))

         , pprFixities (mi_fixities iface)

         , case mi_extra_decls iface of

             Nothing -> empty

             Just eds -> text "extra decls:"

         -- take a strongly-connected group of declarations and compute

         -- its fingerprint.

        fingerprint_group :: (OccEnv (OccName,Fingerprint),

                          -> SCC IfaceDeclABI

                          -> IO (OccEnv (OccName,Fingerprint),

        fingerprint_group (local_env, decls_w_hashes) (AcyclicSCC abi)

           = do let hash_fn = mk_put_name local_env

                    decl = abiDecl abi

                --pprTrace "fingerprinting" (ppr (ifName decl) ) $ do

                hash <- computeFingerprint hash_fn abi

        fingerprint_group (local_env, decls_w_hashes) (CyclicSCC abis)

           = do let stable_abis = sortBy cmp_abiNames abis

                    stable_decls = map abiDecl stable_abis

                local_env1 <- foldM extend_hash_env local_env

                 -- See Note [Fingerprinting recursive groups]

                let hash_fn = mk_put_name local_env1

                -- pprTrace "fingerprinting" (ppr (map ifName decls) ) $ do

                 -- put the cycle in a canonical order

                hash <- computeFingerprint hash_fn stable_abis

                 -- See Note [Fingerprinting recursive groups]

                local_env2 <- foldM extend_hash_env local_env pairs

                return (local_env2, pairs ++ decls_w_hashes)

        -- use when referencing those OccNames in later declarations.

        --

        extend_hash_env :: OccEnv (OccName,Fingerprint)

           return (foldr (\(b,fp) env -> extendOccEnv env b (b,fp)) env0

    --

    (local_env, decls_w_hashes) <-

                        mi_trust iface0)

                         -- Make sure change of Safe Haskell mode causes recomp.

    -- put the declarations in a canonical order, sorted by OccName

        sorted_decls = Map.elems $ Map.fromList $

        -- This key is safe because mi_extra_decls contains tidied things.

        getOcc (IfGblTopBndr b) = getOccName b

    --   - flag abi hash

    --   - foreign stubs and files

    mod_hash <- computeFingerprint putNameLiterally

                        export_hash,  -- includes orphan_hash

                        mi_warns iface0,

                        mi_foreign iface0)

 import GHC.Utils.Outputable

 import GHC.Utils.Misc

 import GHC.Utils.Error

 import GHC.Utils.Panic

 import qualified Data.Traversable as T

     axiom <- rnIfaceGlobal (ifFamInstAxiom d)

     return d { ifFamInstFam = fam, ifFamInstTys = tys, ifFamInstAxiom = axiom }

 rnIfaceDecl :: Rename IfaceDecl

 rnIfaceDecl d@IfaceId{} = do

         IfaceImport(..),

         ImpIfaceList(..),

         -- * Binding names

         IfaceTopBndr,

         putIfaceTopBndr, getIfaceTopBndr,

           --pprTrace "putIfaceTopBndr" (ppr name) $

           putEntry tbl bh (BindingName name)

 data IfaceDecl

   = IfaceId { ifName      :: IfaceTopBndr,

               ifType      :: IfaceType,

        -- different fingerprint!  So we calculate the fingerprint of

        -- each binder by combining the fingerprint of the whole

        -- declaration with the name of the binder. (#5614, #7215)

     [ (occ, computeFingerprint' (hash,occ))

   where

      computeFingerprint' =

        unsafeDupablePerformIO

     -- serialize them out.  See Note [rnIfaceNeverExported] in GHC.Iface.Rename

     -- NB: But coercions are OK, because they will have the right OccName.

     let mk_decl_env decls

                        , case decl of

                             IfaceId { ifIdDetails = IfDFunId } -> False -- exclude DFuns

                             _ -> True ]

                         :: [OccEnv IfaceDecl]

         decl_env = foldl' mergeIfaceDecls emptyOccEnv decl_envs

                         ::  OccEnv IfaceDecl

     -- TODO: change tcIfaceDecls to accept w/o Fingerprint

                                                   (nonDetOccEnvElts decl_env))

     let global_type_env = mkNameEnv names_w_things

     case lookupKnotVars tc_env_vars mod of

    return new_id

 tcIfaceDecls :: Bool

           -> IfL [(Name,TyThing)]

 tcIfaceDecls ignore_prags ver_decls

    = concatMapM (tc_iface_decl_fingerprint ignore_prags) ver_decls

 tc_iface_decl_fingerprint :: Bool                    -- Don't load pragmas into the decl pool

           -> IfL [(Name,TyThing)]   -- The list can be poked eagerly, but the

                                     -- TyThings are forkM'd thunks

   = do  {       -- Populate the name cache with final versions of all

                 -- the names associated with the decl

         -- Typecheck the thing, lazily

         -- NB. Firstly, the laziness is there in case we never need the

                            Nothing    ->

                              pprPanic "tc_iface_decl_fingerprint" (ppr main_name <+> ppr n $$ ppr (decl))

 --         ; traceIf (text "Loading decl for " <> ppr main_name $$ ppr implicit_names)

         ; return $ (main_name, thing) :

 import GHC.Prelude

 import GHC.Iface.Syntax ( IfaceDecl, IfaceClsInst, IfaceFamInst, IfaceRule

 import GHC.Types.TyThing   ( TyThing )

 import GHC.Tc.Types        ( IfL )

 import GHC.Core.InstEnv    ( ClsInst )

 import GHC.Types.CompleteMatch

 import GHC.Types.Annotations ( Annotation )

 import GHC.Types.Name

 tcIfaceDecl            :: Bool -> IfaceDecl -> IfL TyThing

 tcIfaceRules           :: Bool -> [IfaceRule] -> IfL [CoreRule]

 tcIfaceFamInst         :: IfaceFamInst -> IfL FamInst

 tcIfaceAnnotations     :: [IfaceAnnotation] -> IfL [Annotation]

 tcIfaceCompleteMatches :: [IfaceCompleteMatch] -> IfL [CompleteMatch]

         -- perhaps there might be two IfaceTopBndr that are the same

         -- OccName but different Name.  Requires better understanding

         -- of invariants here.

         -- mi_insts = ...,

         -- mi_fam_insts = ...,

   where

     exported_occs = mkOccSet [ nameOccName n

                              | a <- avails

     exported_decls = filter_decls exported_occs

     non_exported_occs = mkOccSet [ occName n

                                  , n <- ifaceDeclNeverExportedRefs d ]

     non_exported_decls = filter_decls non_exported_occs

     dfun_pred IfaceId{ ifIdDetails = IfDFunId } = True

     dfun_pred _ = False

 -- | The list of 'Name's of *non-exported* 'IfaceDecl's which this

 -- 'IfaceDecl' may refer to.  A non-exported 'IfaceDecl' should be kept

 import GHC.Utils.Binary

 import Control.DeepSeq

 {- Note [Interface file stages]

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

 -- a fingerprint, which is used for recompilation checks.

 type family IfaceDeclExts (phase :: ModIfacePhase) = decl | decl -> phase where

   IfaceDeclExts 'ModIfaceCore = IfaceDecl

 type family IfaceBackendExts (phase :: ModIfacePhase) = bk | bk -> phase where

   IfaceBackendExts 'ModIfaceCore = ()

           mi_hash_fn = emptyIfaceHashCache } }

 -- | Constructs cache for the 'mi_hash_fn' field of a 'ModIface'

                  -> (OccName -> Maybe (OccName, Fingerprint))

 mkIfaceHashCache pairs

   = \occ -> lookupOccEnv env occ

   where

     env = foldl' add_decl emptyOccEnv pairs

       where

         add env0 (occ,hash) = extendOccEnv env0 occ (occ,hash)

     `seq` rnf mi_fix_fn

     `seq` rnf mi_hash_fn

 forceModIface :: ModIface -> IO ()

 -- | Records whether a module has orphans. An \"orphan\" is one of:

 --

 -- | Given a 'PartialModIface', turn it into a 'ModIface' by completing

 -- missing fields.

 completePartialModIface :: PartialModIface

   -> Maybe [IfaceBindingX IfaceMaybeRhs IfaceTopBndrInfo]

   -> ModIfaceBackend

   -> ModIface

 import GHC.Types.Unique

 import qualified GHC.Data.Strict as Strict

 import GHC.Utils.Outputable( JoinPointHood(..) )

 import Control.DeepSeq

 import Control.Monad            ( when, (<$!>), unless, forM_, void )

 #if MIN_VERSION_base(4,15,0)

 import GHC.ForeignPtr           ( unsafeWithForeignPtr )

 #endif

 import Unsafe.Coerce (unsafeCoerce)

 lazyPut :: Binary a => WriteBinHandle -> a -> IO ()

 lazyPut = lazyPut' put_

 lazyGet = lazyGet' get

 lazyPut' :: (WriteBinHandle -> a -> IO ()) -> WriteBinHandle -> a -> IO ()

     putAtRel bh pre_a q    -- fill in slot before a with ptr to q

     seekBinWriter bh q        -- finally carry on writing at q

 lazyGet' f bh = do

     p <- getRelBin bh -- a BinPtr

     p_a <- tellBinReader bh

     a <- unsafeInterleaveIO $ do

         -- NB: Use a fresh rbm_off_r variable in the child thread, for thread

         -- safety.

         off_r <- newFastMutInt 0

         let bh' = bh { rbm_off_r = off_r }

         seekBinReader bh' p_a