ms_dyn_obj_date = Nothing,

         ms_iface_date = hi_timestamp,

         ms_hie_date = hie_timestamp,

         ms_srcimps = [],

         ms_textual_imps = ((,,) NormalLevel NoPkgQual . noLoc) <$> extra_sig_imports,

         ms_parsed_mod = Just (HsParsedModule {

             ms_hs_hash = fingerprint0,

             ms_obj_date = Nothing, -- TODO do this, but problem: hi_timestamp is BOGUS

             ms_dyn_obj_date = Nothing, -- TODO do this, but problem: hi_timestamp is BOGUS

             ms_iface_date = hi_timestamp,

             ms_hie_date = hie_timestamp

           }

   dyn_obj_timestamp <- modificationTimeIfExists (ml_dyn_obj_file_ospath nms_location)

   hi_timestamp <- modificationTimeIfExists (ml_hi_file_ospath nms_location)

   hie_timestamp <- modificationTimeIfExists (ml_hie_file_ospath nms_location)

   extra_sig_imports <- findExtraSigImports hsc_env nms_hsc_src pi_mod_name

   (implicit_sigs, _inst_deps) <- implicitRequirementsShallow (hscSetActiveUnitId (moduleUnitId nms_mod) hsc_env) pi_theimps

         , ms_hie_date = hie_timestamp

         , ms_obj_date = obj_timestamp

         , ms_dyn_obj_date = dyn_obj_timestamp

         }

 data PreprocessedImports

            | otherwise -> do

                -- Check the status of all the linkable types we might need.

                -- 1. The in-memory linkable we had at hand.

                -- 2. The bytecode object file

                -- 3. Bytecode from an interface's whole core bindings.

                bc_core_linkable <- checkByteCodeFromIfaceCoreBindings hsc_env checked_iface mod_summary

                -- 4. The object file.

                trace_if (hsc_logger hsc_env)

                 (vcat [text "BCO linkable", nest 2 (ppr bc_in_memory_linkable)

                       , text "BCO obj linkable", ppr bc_obj_linkable

 -- | Check that the .o files produced by compilation are already up-to-date

 -- or not.

   let

     dt_enabled  = gopt Opt_BuildDynamicToo dflags

     this_mod    = ms_mod summary

     mb_dyn_obj_date = ms_dyn_obj_date summary

     mb_if_date  = ms_iface_date summary

     obj_fn      = ml_obj_file (ms_location summary)

       -- Not in dynamic-too mode

       else k

   checkDynamicObj $

             disk_hash <- getFileHash obj_fn

 -- | Check to see if we can reuse the old linkable, by this point we will

 -- have just checked that the old interface matches up with the source hash, so

 -- no need to check that again here

   case mb_old_linkable of

     Just old_linkable -> do

       -- If `-fwrite-byte-code` is enabled, then check that the .gbc file is

       -- up-to-date with the linkable we have in our hand.

       ok <- if gopt Opt_WriteByteCode (hsc_dflags hsc_env)

               else pure True

       if ok

         then return (UpToDateItem old_linkable)

     _ -> return $ outOfDateItemBecause MissingBytecode Nothing

 -- | Load bytecode from a ".gbc" object file if it exists and is up-to-date

   let

     obj_fn = ml_bytecode_file (ms_location mod_sum)

 -- | Attempt to load bytecode from whole core bindings in the interface if they exist.

 -- This is a legacy code-path, these days it should be preferred to use the bytecode object linkable.

         -- Add the object linkable to the potential bytecode linkable which was generated in HscBackend.

         return (mlinkable { homeMod_object = Just linkable })

   -- when building ghc-internal with --make (e.g. with cabal-install), we want

   -- the virtual interface for gHC_PRIM in the cache, not the empty one.

   let miface_final

         | ms_mod mod_sum == gHC_PRIM = getGhcPrimIface (hsc_hooks hsc_env)

   return (miface_final, final_linkable)

 asPipeline :: P m => Bool -> PipeEnv -> HscEnv -> Maybe ModLocation -> FilePath -> m (Maybe ObjFile)

 import GHC.Unit.Home

 import GHC.Data.Maybe

 import GHC.Iface.Make

 import GHC.Driver.Config.Parser

 import GHC.Parser.Header

 import GHC.Data.StringBuffer

               final_iface <- mkFullIface hsc_env partial_iface stg_infos cg_infos iface_stubs iface_files

               mlinkable <-

                 if gopt Opt_ByteCodeAndObjectCode dflags

                   then do

               -- In interpreted mode the regular codeGen backend is not run so we

               -- generate a interface without codeGen info.

             do

               bc <- generateAndWriteByteCodeLinkable hsc_env (mkCgInteractiveGuts cgguts) mod_location

               return ([], final_iface, emptyHomeModInfoLinkable { homeMod_bytecode = Just bc } , panic "interpreter")

   hie_date <- modificationTimeIfExists hie_file

   o_mod <- modificationTimeIfExists o_file

   dyn_o_mod <- modificationTimeIfExists dyn_o_file

   -- Tell the finder cache about this module

   mod <- do

                                 ms_parsed_mod   = Nothing,

                                 ms_iface_date   = hi_date,

                                 ms_hie_date     = hie_date,

                                 ms_textual_imps = imps,

                                 ms_srcimps      = src_imps }

    , recompileRequired

    , addFingerprints

    , mkSelfRecomp

    )

 where

                 , mi_sr_opt_hash = opt_hash

                 , mi_sr_plugin_hash = plugin_hash

                 , mi_sr_src_hash = src_hash

 -- | Add fingerprints for top-level declarations to a 'ModIface'.

 --

    --

   return final_iface

 -- The ABI hash should depend on everything in IfacePublic

                        -- ^ Hash of hpc flags

                        , mi_sr_plugin_hash :: !Fingerprint

                        -- ^ Hash of plugins

                        }

 instance Binary IfaceSelfRecomp where

     put_ bh mi_sr_src_hash

     lazyPut bh mi_sr_usages

     put_ bh mi_sr_flag_hash

     put_ bh mi_sr_opt_hash

     put_ bh mi_sr_hpc_hash

     put_ bh mi_sr_plugin_hash

   get bh = do

     src_hash    <- get bh

     opt_hash    <- get bh

     hpc_hash    <- get bh

     plugin_hash <- get bh

 instance Outputable IfaceSelfRecomp where

     = vcat [text "Self-Recomp"

             , nest 2 (vcat [ text "src hash:" <+> ppr mi_sr_src_hash

                            , text "flags:" <+> pprFingerprintWithValue missingExtraFlagInfo (fmap pprIfaceDynFlags mi_sr_flag_hash)

                            , text "opt hash:" <+> ppr mi_sr_opt_hash

                            , text "hpc hash:" <+> ppr mi_sr_hpc_hash

                            , text "plugin hash:" <+> ppr mi_sr_plugin_hash

                            , text "usages:" <+> ppr (map pprUsage mi_sr_usages)

                            ])]

 instance NFData IfaceSelfRecomp where

 pprFingerprintWithValue :: SDoc -> FingerprintWithValue SDoc -> SDoc

 pprFingerprintWithValue missingInfo (FingerprintWithValue fp mflags)

 import GHC.Unit.Module

 import GHC.Unit.Module.ModNodeKey

 import GHC.Unit.Module.Graph

 import GHC.Unit.Module.ModIface

 import GHC.Unit.State as Packages

     go :: ModuleGraph -> IO ([Module], UniqDSet UnitId)

     go mg = do

         let mod_keys = map (hmgModKey mg) mods

         (mods_s, pkgs_s) <- partitionEithers <$> mapMaybeM get_mod_info all_reachable

         return (mods_s, mkUniqDSet pkgs_s)

     -- transitive closure of Z?

    , mgReachable

    , mgReachableLoop

    , mgQuery

    , ZeroScopeKey(..)

    , mgQueryZero

   , mg_graph :: (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode)

   , mg_loop_graph :: (ReachabilityIndex SummaryNode, NodeKey -> Maybe SummaryNode)

   , mg_zero_graph :: (ReachabilityIndex ZeroSummaryNode, ZeroScopeKey -> Maybe ZeroSummaryNode)

     -- `mg_graph` and `mg_loop_graph` cached transitive dependency calculations

     -- so that a lot of work is not repeated whenever the transitive

 emptyMG = ModuleGraph [] (graphReachability emptyGraph, const Nothing)

                          (graphReachability emptyGraph, const Nothing)

                          (graphReachability emptyGraph, const Nothing)

                          False

                          emptyUniqMap

   modules_below =

     allReachableMany td_map (mapMaybe lookup_node nk)

 -- | @'mgQueryZero' g root target@ answers the question: can we reach @target@ from @root@

 -- in the module graph @g@, only using normal (level 0) imports?

     , mg_graph =  mkTransDeps new_mss

     , mg_loop_graph = mkTransLoopDeps new_mss

     , mg_zero_graph = mkTransZeroDeps new_mss

     , mg_has_holes = mg_has_holes || maybe False isHsigFile (moduleNodeInfoHscSource =<< mgNodeIsModule node)

     , mg_home_module_name_providers_map = mkHomeModuleNameProvidersMap new_mss

     }

    , set_mi_sig_of

    , set_mi_hsc_src

    , set_mi_self_recomp

    , set_mi_hi_bytes

    , set_mi_deps

    , set_mi_exports

 set_mi_self_recomp :: Maybe IfaceSelfRecomp-> ModIface_ phase -> ModIface_ phase

 set_mi_self_recomp val iface = clear_mi_hi_bytes $ iface { mi_self_recomp_ = val }

 set_mi_hi_bytes :: IfaceBinHandle phase -> ModIface_ phase -> ModIface_ phase

 set_mi_hi_bytes val iface = iface { mi_hi_bytes_ = val }

           -- ^ Timestamp of object, if we have one

         ms_dyn_obj_date     :: !(Maybe UTCTime),

           -- ^ Timestamp of dynamic object, if we have one

         ms_iface_date   :: Maybe UTCTime,

           -- ^ Timestamp of hi file, if we have one

           -- See Note [When source is considered modified] and #9243