| 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

                bc_obj_linkable <- checkByteCodeFromObject hsc_env mod_summary

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

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

 checkByteCodeInMemory hsc_env mod_sum mb_old_linkable =

   case mb_old_linkable of

     Just old_linkable

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

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

       -- If ms_bytecode_date is Nothing, then the .gbc file does not exist yet.

       -- Otherwise, check that the date matches the linkable date exactly.

           then maybe False (linkableTime old_linkable ==) (ms_bytecode_date mod_sum)

           else True

       -> return $ (UpToDateItem old_linkable)

     _ -> return $ outOfDateItemBecause MissingBytecode Nothing

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

 checkByteCodeFromObject hsc_env mod_sum = do

   let

     obj_fn = ml_bytecode_file (ms_location mod_sum)

           -- that the one we have on disk would be suitable as well.

           linkable <- unsafeInterleaveIO $ do

             bco <- ByteCode.readBinByteCode hsc_env obj_fn

           return $ UpToDateItem linkable

     _ -> return $ outOfDateItemBecause MissingBytecode Nothing

 import GHC.Unit.Module.ModGuts

 import GHC.Unit.Module.ModIface

 import GHC.Utils.Fingerprint

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 -- | Status of a module in incremental compilation

 data HscRecompStatus

 safeCastHomeModLinkable :: HomeModLinkable -> RecompLinkables

 safeCastHomeModLinkable (HomeModLinkable bc o) = RecompLinkables (NormalLinkable bc) o

 justBytecode = \case

   Right lm -> emptyRecompLinkables { recompLinkables_bytecode = WholeCoreBindingsLinkable lm }

 justObjects :: Linkable -> RecompLinkables

   assertPpr (linkableIsNativeCodeOnly lm) (ppr lm)

     $ emptyRecompLinkables { recompLinkables_object = Just lm }

 bytecodeAndObjects either_bc o = case either_bc of

   Left bc ->

   Right bc ->

     assertPpr (linkableIsNativeCodeOnly o) (ppr o)

       $ RecompLinkables (WholeCoreBindingsLinkable bc) (Just o)