{-# LANGUAGE NondecreasingIndentation, ScopedTypeVariables #-}

 {-# LANGUAGE TupleSections, NamedFieldPuns #-}

 {-# LANGUAGE TypeFamilies #-}

 {-# LANGUAGE PatternSynonyms #-}

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

         ModuleGraph, emptyMG, mapMG, mkModuleGraph, mgModSummaries,

         mgLookupModule,

         ModSummary(..), ms_mod_name, ModLocation(..),

         getModSummary,

         getModuleGraph,

         isLoaded,

   , (</>)

   , (<.>)

   , splitSearchPath

   , isRelative

   , dropTrailingPathSeparator

   , takeDirectory

   , doesDirectoryExist

   , doesFileExist

   , getDirectoryContents

 import GHC.Utils.Panic (panic)

 import System.OsPath

 import System.Directory.OsPath (doesDirectoryExist, doesFileExist, getDirectoryContents, createDirectoryIfMissing)

 import System.Directory.Internal (os)

 -- | Decode an 'OsPath' to 'FilePath', throwing an 'error' if decoding failed.

 module GHC.Data.Strict (

     Maybe(Nothing, Just),

     fromMaybe,

     Pair(And),

     -- Not used at the moment:

     --

     -- Either(Left, Right),

   ) where

 import GHC.Prelude hiding (Maybe(..), Either(..))

 import Control.Applicative

 import Data.Semigroup

 import Data.Data

 fromMaybe d Nothing = d

 fromMaybe _ (Just x) = x

 apMaybe :: Maybe (a -> b) -> Maybe a -> Maybe b

 apMaybe (Just f) (Just x) = Just (f x)

 apMaybe _ _ = Nothing

 import qualified GHC.LanguageExtensions as LangExt

 import GHC.Data.Maybe

 import GHC.Data.StringBuffer

 import GHC.Data.FastString

 import qualified GHC.Data.OsPath as OsPath

     let PackageName pn_fs = pn

     let location = mkHomeModLocation2 fopts mod_name

     env <- getBkpEnv

     src_hash <- liftIO $ getFileHash (bkp_filename env)

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

     -- A travesty!

     let location0 = mkHomeModLocation2 fopts modname

                               moduleNameSlashes modname)

                               (case hsc_src of

     -- DANGEROUS: bootifying can POISON the module finder cache

     let location = case hsc_src of

                         HsBootFile -> addBootSuffixLocnOut location0

 import GHC.Driver.Ppr

 import GHC.Driver.Backend

 import qualified GHC.Data.ShortText as ST

 import GHC.Data.Stream           ( Stream )

 import qualified GHC.Data.Stream as Stream

            Maybe FilePath) -- C file created

 outputForeignStubs logger tmpfs dflags unit_state mod location stubs

  = do

    stub_c <- newTempName logger tmpfs (tmpDir dflags) TFL_CurrentModule "c"

    case stubs of

 import GHC.Driver.DynFlags

 import GHC.Unit.Finder.Types

 import GHC.Data.FastString

 -- | Create a new 'FinderOpts' from DynFlags.

 initFinderOpts :: DynFlags -> FinderOpts

 initFinderOpts flags = FinderOpts

   , finder_lookupHomeInterfaces = isOneShot (ghcMode flags)

   , finder_bypassHiFileCheck = MkDepend == (ghcMode flags)

   , finder_ways = ways flags

   , finder_enableSuggestions = gopt Opt_HelpfulErrors flags

   , finder_thisPackageName  = mkFastString <$> thisPackageName flags

   , finder_hiddenModules = hiddenModules flags

   , finder_reexportedModules = reexportedModules flags

   }

 import GHC.Data.FastString

 import GHC.Data.Bag

 import GHC.Data.StringBuffer

 import qualified GHC.Data.Stream as Stream

 import GHC.Data.Stream (Stream)

              rawCmms

         return stub_c_exists

   where

 -------------------- Stuff for new code gen ---------------------

     {- Desugar it -}

     -- We use a basically null location for iNTERACTIVE

     ds_result <- hscDesugar' iNTERACTIVELoc tc_gblenv

     {- Simplify -}

   {- Lint if necessary -}

   lintInteractiveExpr (text "hscCompileCoreExpr") hsc_env prepd_expr

   -- Ensure module uniqueness by giving it a name like "GhciNNNN".

   -- This uniqueness is needed by the JS linker. Without it we break the 1-1

 import GHC.Data.Graph.Directed

 import GHC.Data.FastString

 import GHC.Data.Maybe      ( expectJust )

 import GHC.Data.StringBuffer

 import qualified GHC.LanguageExtensions as LangExt

                      tn <- newTempName logger tmpfs (tmpDir dflags) staticLife suf

                      let dyn_tn = tn -<.> dynsuf

                      addFilesToClean tmpfs dynLife [dyn_tn]

                  -- We don't want to create .o or .hi files unless we have been asked

                  -- to by the user. But we need them, so we patch their locations in

                  -- the ModSummary with temporary files.

                  -- If ``-fwrite-interface` is specified, then the .o and .hi files

                  -- are written into `-odir` and `-hidir` respectively.  #16670

                  if gopt Opt_WriteInterface dflags

                    else (,) <$> (new_temp_file (hiSuf_ dflags) (dynHiSuf_ dflags))

                             <*> (new_temp_file (objectSuf_ dflags) (dynObjectSuf_ dflags))

                let new_dflags = case enable_spec of

                                   EnableByteCodeAndObject -> (gopt_set dflags Opt_ByteCodeAndObjectCode) { backend = defaultBackendOf ms}

                let ms' = ms

                      { ms_location =

                      , ms_hspp_opts = updOptLevel 0 $ new_dflags

                      }

                -- Recursive call to catch the other cases

         let fopts = initFinderOpts (hsc_dflags hsc_env)

         -- Make a ModLocation for this file

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

 import GHC.Driver.Session (pgm_F)

 import qualified GHC.SysTools as SysTools

 import GHC.Data.Graph.Directed ( SCC(..) )

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 import GHC.Types.SourceError

   updateJson m_dep_json (updateDepJSON include_pkg_deps pp dep_node deps)

   writeDependencies include_pkg_deps root hdl extra_suffixes dep_node deps

   where

     include_pkg_deps = depIncludePkgDeps dflags

     dep_node =

       DepNode {

         dn_mod = ms_mod node,

         dn_src = src_file,

         dn_boot = isBootSummary node,

         dn_options = Set.fromList (ms_opts node)

       }

     cpp_deps = do

       session <- Session <$> newIORef hsc_env

       parsedMod <- reflectGhc (GHC.parseModule node) session

     -- Emit a dependency for each import

     import_deps is_boot idecls =

     Found loc dep_mod ->

       pure DepHi {

         dep_mod,

         dep_unit = lookupUnitId (hsc_units hsc_env) (moduleUnitId dep_mod),

         dep_local,

         dep_boot

   Bool ->

   FilePath ->

   Handle ->

   DepNode ->

   [Dep] ->

   IO ()

     DepNode {dn_src, dn_obj, dn_hi, dn_boot} = node

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

 -- (writeDependency r h [t1,t2] dep) writes to handle h the dependency

 --      t1 t2 : dep

 writeDependency root hdl targets dep

            --     c:/foo/...

            -- on cygwin as make gets confused by the :

            -- Making relative deps avoids some instances of this.

            output = unwords (map forOutput targets) ++ " : " ++ forOutput dep'

        hPutStrLn hdl output

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

 insertSuffixes

         -- Note that the extra bit gets inserted *before* the old suffix

         -- We assume the old suffix contains no dots, so we know where to

         -- split it

 insertSuffixes file_name extras

   where

                          -- Drop the "." from the extension

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

 import GHC.Utils.Json

 import GHC.Utils.Misc

 import GHC.Utils.Outputable

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

 -- Output helpers

 data DepNode =

   DepNode {

     dn_mod :: Module,

     dn_boot :: IsBootInterface,

     dn_options :: Set.Set String

   }

 data Dep =

   DepHi {

     dep_mod :: Module,

     dep_unit :: Maybe UnitInfo,

     dep_local :: Bool,

     dep_boot :: IsBootInterface

   }

   |

   DepCpp {

   }

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

 data Deps =

   Deps {

     modules :: (Set.Set ModuleName, Set.Set ModuleName),

     packages :: PackageDeps,

     options :: Set.Set String,

     preprocessor :: Maybe FilePath

   }

   json (DepJSON m) =

     JSObject [

       (moduleNameString target, JSObject [

         ("modules", array (fst modules) moduleNameString),

         ("modules-boot", array (snd modules) moduleNameString),

         ("packages",

             ((name, unit_id, package_id), mods) <- Map.toList packages

           ]

         ),

         ("options", array options id),

         ("preprocessor", maybe JSNull JSString preprocessor)

       ])

 import GHC.Driver.Config.Parser

 import GHC.Parser.Header

 import GHC.Data.StringBuffer

 import GHC.Types.SourceError

 import GHC.Unit.Finder

 import Data.IORef

 mkOneShotModLocation pipe_env dflags src_flavour mod_name = do

     let PipeEnv{ src_basename=basename,

              src_suffix=suff } = pipe_env

     -- Boot-ify it if necessary

     let location2

     -- This can't be done in mkHomeModuleLocation because

     -- it only applies to the module being compiles

     let ohi = outputHi dflags

                   | otherwise      = location2

     let dynohi = dynOutputHi dflags

                   | otherwise         = location3

     -- Take -o into account if present

         location5 | Just ofile <- expl_o_file

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

                   , isNoLink (ghcLink dflags)

                   | Just dyn_ofile <- expl_dyn_o_file

                   | otherwise = location4

     return location5

     where

 import GHC.Driver.DynFlags

 import GHC.Driver.Env

 import GHC.Data.Maybe

 import GHC.Prelude

 import GHC.Unit

 import GHC.Unit.Env

             InstalledNotFound files mb_pkg

                 | Just pkg <- mb_pkg

                 , notHomeUnitId mhome_unit pkg

                 | null files

                 -> NotAModule

                 | otherwise

             _ -> panic "cantFindInstalledErr"

 import GHC.Builtin.Names ( gHC_PRIM )

 import GHC.Unit.Env

 import GHC.Unit.Types

 import GHC.Unit.Module

 import GHC.Unit.State

 import GHC.Unit.Finder.Types

 import qualified GHC.Data.ShortText as ST

 import GHC.Utils.Misc

 import GHC.Fingerprint

 import Data.IORef

 import Control.Monad

 import Data.Time

 import qualified Data.Map as M

 import GHC.Driver.Config.Finder

 import GHC.Unit.Module.Graph (mgHomeModuleMap, ModuleNameHomeMap)

 import qualified Data.Set as Set

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

 -- The Finder

         -- implicit locations from the instances

         InstalledFound loc   _ -> return (Found loc m)

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

                                          , fr_pkgs_hidden = []

                                          , fr_mods_hidden = []

                                          , fr_unusables = []

     InstalledFound loc _ -> Found loc (mkHomeModule home_unit mod_name)

     InstalledNoPackage _ -> NoPackage uid -- impossible

     InstalledNotFound fps _ -> NotFound {

         fr_pkg = Just uid,

         fr_mods_hidden = [],

         fr_pkgs_hidden = [],

     InstalledFound loc _ -> Found loc (mkModule uid mod_name)

     InstalledNoPackage _ -> NoPackage uid -- impossible

     InstalledNotFound fps _ -> NotFound {

         fr_pkg = Just uid,

         fr_mods_hidden = [],

         fr_pkgs_hidden = [],

      hi_dir_path =

       case finder_hiDir fopts of

         Just hiDir -> case maybe_working_dir of

         Nothing -> home_path

      hisuf = finder_hiSuf fopts

      mod = mkModule home_unit mod_name

      source_exts =

       ]

      -- we use mkHomeModHiOnlyLocation instead of mkHiOnlyModLocation so that

          else searchPathExts search_dirs mod exts

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

 augmentImports _work_dir [] = []

 -- | Search for a module in external packages only.

 findPackageModule :: FinderCache -> UnitState -> FinderOpts -> InstalledModule -> IO InstalledFindResult

        tag = waysBuildTag (finder_ways fopts)

              -- hi-suffix for packages depends on the build tag.

        mk_hi_loc = mkHiOnlyModLocation fopts package_hisuf package_dynhisuf

         -- we never look for a .hi-boot file in an external package;

         -- .hi-boot files only make sense for the home package.

     in

       [one] | finder_bypassHiFileCheck fopts ->

             -- there's only one place that this .hi file can be, so

             -- don't bother looking for it.

                 loc = mk_hi_loc one basename

             in return $ InstalledFound loc mod

       _otherwise ->

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

 -- General path searching

                -> InstalledModule -- module name

                -> [ (

                     )

                   ]

                -> IO InstalledFindResult

 searchPathExts paths mod exts = search to_search

   where

     to_search = [ (file, fn path basename)

                 | path <- paths,

                   (ext,fn) <- exts,

                            | otherwise   = path </> basename

                       file = base <.> ext

                 ]

         else search rest

 mkHomeModLocationSearched :: FinderOpts -> ModuleName -> FileExt

 mkHomeModLocationSearched fopts mod suff path basename =

   mkHomeModLocation2 fopts mod (path </> basename) suff

 -- ext

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

 mkHomeModLocation dflags mod src_filename =

    in mkHomeModLocation2 dflags mod basename extension

 mkHomeModLocation2 :: FinderOpts

                    -> ModuleName

                    -> ModLocation

 mkHomeModLocation2 fopts mod src_basename ext =

        obj_fn = mkObjPath  fopts src_basename mod_basename

        dyn_obj_fn = mkDynObjPath  fopts src_basename mod_basename

        dyn_hi_fn  = mkDynHiPath   fopts src_basename mod_basename

        hie_fn = mkHiePath  fopts src_basename mod_basename

 mkHomeModHiOnlyLocation :: FinderOpts

                         -> ModuleName

                         -> BaseName

                         -> ModLocation

 mkHomeModHiOnlyLocation fopts mod path basename =