let loc = srcLocSpan (mkSrcLoc (mkFastString (bkp_filename env)) 1 1)

     let fc = hsc_FC hsc_env

     extra_sig_imports <- liftIO $ findExtraSigImports hsc_env HsigFile mod_name

     -- To add insult to injury, we don't even actually use

     -- these filenames to figure out where the hi files go.

     -- A travesty!

                              (unsafeEncodeUtf $ unpackFS unit_fs </>

                               moduleNameSlashes modname)

                                 HsigFile   -> os "hsig"

                                 HsBootFile -> os "hs-boot"

                                 HsSrcFile  -> os "hs")

     -- This duplicates a pile of logic in GHC.Driver.Make

     hi_timestamp <- liftIO $ modificationTimeIfExists (ml_hi_file location)

     hie_timestamp <- liftIO $ modificationTimeIfExists (ml_hie_file location)

     this_mod <- liftIO $ do

       let home_unit = hsc_home_unit hsc_env

       let fc        = hsc_FC hsc_env

     let ms = ModSummary {

             ms_mod = this_mod,

             ms_hsc_src = hsc_src,

             <- getPreprocessedImports hsc_env src_fn mb_phase maybe_buf

         let fopts = initFinderOpts (hsc_dflags hsc_env)

         -- Tell the Finder cache where it is, so that subsequent calls

         -- to findModule will find it, even if it's not on any search path

         mod <- liftIO $ do

           let home_unit = hsc_home_unit hsc_env

           let fc        = hsc_FC hsc_env

         liftIO $ makeNewModSummary hsc_env $ MakeNewModSummary

             { nms_src_fn = src_fn

            -- and it was likely flushed in depanal. This is not technically

            -- needed when we're called from sumariseModule but it shouldn't

            -- hurt.

            hi_timestamp <- modificationTimeIfExists (ml_hi_file location)

            hie_timestamp <- modificationTimeIfExists (ml_hie_file location)

     find_it :: IO SummariseResult

     find_it = do

         case found of

              Found location mod

                 | isJust (ml_hs_file location) ->

     just_found location mod = do

                 -- Adjust location to point to the hs-boot source file,

                 -- hi file, object file, when is_boot says so

                 -- Check that it exists

                 -- It might have been deleted since the Finder last found it

           -- .hs-boot file doesn't exist.

           Nothing -> return NotThere

           Just h  -> do

             return $ case fresult of

               Left err -> FoundHomeWithError (moduleUnitId mod, err)

               Right ms -> FoundHome ms

 findDependency hsc_env srcloc pkg imp dep_boot = do

   -- Find the module; this will be fast because

   -- we've done it once during downsweep

     Found loc dep_mod ->

       pure DepHi {

         dep_mod,

     -- e.g.         A.o   : B.hi

     --              A.x_o : B.x_hi

     import_dep = \case

         | isNothing dep_unit || include_pkgs

         | otherwise

         -> []

    isDynLibSuffix,

    isHaskellUserSrcSuffix,

    isHaskellSigSuffix,

    isSourceSuffix,

    isHaskellishTarget,

 phaseInputExt StopLn              = "o"

 haskellish_src_suffixes, backpackish_suffixes, haskellish_suffixes, cish_suffixes,

  :: [String]

 -- When a file with an extension in the haskellish_src_suffixes group is

 -- loaded in --make mode, its imports will be loaded too.

 -- Will not be deleted as temp files:

 haskellish_user_src_suffixes =

 haskellish_sig_suffixes      = [ "hsig", "lhsig" ]

 backpackish_suffixes         = [ "bkp" ]

   _         -> ["so"]

 isHaskellishSuffix, isBackpackishSuffix, isHaskellSrcSuffix, isCishSuffix,

  :: String -> Bool

 isHaskellishSuffix     s = s `elem` haskellish_suffixes

 isBackpackishSuffix    s = s `elem` backpackish_suffixes

 isHaskellSigSuffix     s = s `elem` haskellish_sig_suffixes

 isHaskellSrcSuffix     s = s `elem` haskellish_src_suffixes

 isCishSuffix           s = s `elem` cish_suffixes

 isJsSuffix             s = s `elem` js_suffixes

   mod <- do

     let home_unit = hsc_home_unit hsc_env

     let fc        = hsc_FC hsc_env

   -- Make the ModSummary to hand to hscMain

   let

 mkOneShotModLocation pipe_env dflags src_flavour mod_name = do

     let PipeEnv{ src_basename=basename,

              src_suffix=suff } = pipe_env

     -- Take -ohi into account if present

     -- This can't be done in mkHomeModuleLocation because

     -- it only applies to the module being compiles

     let ohi = outputHi dflags

     let dynohi = dynOutputHi dflags

     -- Take -o into account if present

     -- Very like -ohi, but we must *only* do this if we aren't linking

         location5 | Just ofile <- expl_o_file

                   , let dyn_ofile = fromMaybe (ofile -<.> dynObjectSuf_ dflags) expl_dyn_o_file

                   , isNoLink (ghcLink dflags)

                               , ml_dyn_obj_file_ospath = unsafeEncodeUtf dyn_ofile }

                   | Just dyn_ofile <- expl_dyn_o_file

     return location5

     where

       fopts = initFinderOpts dflags

       else do

           let fopts = initFinderOpts dflags

           -- Look for the file

           case mb_found of

                   -- See Note [Home module load error]

                   case mhome_unit of

                     Just home_unit

         Maybe.Failed err -> pure (Maybe.Failed err)

         Maybe.Succeeded iface ->

           find_location mod <&> \case

             err -> Maybe.Failed $

                    cannotFindInterface unit_state home_unit

                    (targetProfile dflags) (moduleName mod) err

     find_location mod =

       liftIO $

       findExactModule (hsc_FC hsc_env) (initFinderOpts dflags)

     other_fopts = initFinderOpts . homeUnitEnv_dflags <$> hsc_HUG hsc_env

     initFinderCache,

     flushFinderCaches,

     findImportedModule,

     findPluginModule,

     findExactModule,

     findHomeModule,

 import GHC.Linker.Types

 import GHC.Types.PkgQual

 import GHC.Fingerprint

 import Data.IORef

     query <- hscUnitIndexQuery hsc_env

     findImportedModuleNoHsc fc fopts (hsc_unit_env hsc_env) query home_module_map mhome_unit mod pkg_qual

 findImportedModuleNoHsc

   :: FinderCache

   -> FinderOpts

 -- reading the interface for a module mentioned by another interface,

 -- for example (a "system import").

     Just home_unit

      | isHomeInstalledModule home_unit mod

         -> findInstalledHomeModule fc fopts (homeUnitId home_unit) (moduleName mod)

      | Just home_fopts <- HUG.unitEnv_lookup_maybe (moduleUnit mod) other_fopts

         -> findInstalledHomeModule fc home_fopts (moduleUnit mod) (moduleName mod)

     _ -> findPackageModule fc unit_state fopts mod

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

 -- Helpers

         -- with just the location of the thing that was

         -- instantiated; you probably also need all of the

         -- implicit locations from the instances

         InstalledNoPackage   _ -> return (NoPackage (moduleUnit m))

         InstalledNotFound fp _ -> return (NotFound{ fr_paths = fmap unsafeDecodeUtf fp, fr_pkg = Just (moduleUnit m)

                                          , fr_pkgs_hidden = []

         addToFinderCache fc mod result

         return result

   let imod = toUnitId <$> mod

 -- This returns a module because it's more convenient for users

   let mod = mkHomeInstalledModule home_unit mod_name

   return (mkHomeModule home_unit mod_name)

 uncacheModule :: FinderCache -> HomeUnit -> ModuleName -> IO ()

   let uid       = homeUnitAsUnit home_unit

   r <- findInstalledHomeModule fc fopts (homeUnitId home_unit) mod_name

   return $ case r of

     InstalledNoPackage _ -> NoPackage uid -- impossible

     InstalledNotFound fps _ -> NotFound {

         fr_paths = fmap unsafeDecodeUtf fps,

   let uid       = RealUnit (Definite home_unit)

   r <- findInstalledHomeModule fc fopts home_unit mod_name

   return $ case r of

     InstalledNoPackage _ -> NoPackage uid -- impossible

     InstalledNotFound fps _ -> NotFound {

         fr_paths = fmap unsafeDecodeUtf fps,

    -- This is important only when compiling the base package (where GHC.Prim

    -- is a home module).

    if mod `installedModuleEq` gHC_PRIM

          else searchPathExts search_dirs mod exts

 -- | Prepend the working directory to the search path.

     -- special case for GHC.Prim; we won't find it in the filesystem.

     if mod `installedModuleEq` gHC_PRIM

           else

     let

             -- don't bother looking for it.

             let basename = unsafeEncodeUtf $ moduleNameSlashes (moduleName mod)

                 loc = mk_hi_loc one basename

       _otherwise ->

             searchPathExts import_dirs mod [(package_hisuf, mk_hi_loc)]

     search ((file, loc) : rest) = do

       b <- doesFileExist file

       if b

         else search rest

 mkHomeModLocationSearched :: FinderOpts -> ModuleName -> FileExt

 -- ext

 --      The filename extension of the source file (usually "hs" or "lhs").

 mkHomeModLocation2 :: FinderOpts

                    -> ModuleName

                                }

 data InstalledFindResult

   | InstalledNoPackage UnitId

   | InstalledNotFound [OsPath] (Maybe UnitId)

     )

    , pattern ModLocation

    , addBootSuffix

    , addBootSuffixLocn

    , addBootSuffixLocnOut

    , removeBootSuffix

 import GHC.Prelude

 import GHC.Data.OsPath

 import GHC.Utils.Outputable

 import qualified System.OsString as OsString

     Just path -> path

     Nothing -> error "removeBootSuffix: no -boot suffix"

 -- | Add the @-boot@ suffix to all file paths associated with the module

 addBootSuffixLocn :: ModLocation -> ModLocation

 addBootSuffixLocn locn

 -- | Add the @-boot@ suffix to all output file paths associated with the

 -- module, not including the input file itself

           , ml_dyn_obj_file_ospath = unsafeEncodeUtf ml_dyn_obj_file

           , ml_hie_file_ospath = unsafeEncodeUtf ml_hie_file

           }