{-# LANGUAGE DuplicateRecordFields #-}

module Distribution.Client.InLibrary
  ( libraryConfigureInputsFromElabPackage
  , configure
  , build
  , haddock
  , copy
  , register
  , repl
  , test
  , bench
  )
where

import Distribution.Backpack.DescribeUnitId (setupMessage')
import Distribution.Client.ProjectPlanning.Types
import Distribution.Client.RebuildMonad
import qualified Distribution.Client.SetupHooks.CallHooksExe as ExternalHooksExe
  ( buildTypePreBuildHooks
  , buildTypeSetupHooks
  )
import Distribution.Client.Types

import qualified Distribution.PackageDescription as PD
import Distribution.Simple (Compiler, PackageDBStackCWD)
import qualified Distribution.Simple.Bench as Cabal
import Distribution.Simple.Build (build_setupHooks, repl_setupHooks)
import qualified Distribution.Simple.Configure as Cabal
import Distribution.Simple.Haddock (haddock_setupHooks)
import Distribution.Simple.Install (install_setupHooks)
import Distribution.Simple.LocalBuildInfo (mbWorkDirLBI)
import Distribution.Simple.PackageIndex (InstalledPackageIndex)
import qualified Distribution.Simple.PreProcess as Cabal
import Distribution.Simple.Program.Db
import qualified Distribution.Simple.Register as Cabal
import qualified Distribution.Simple.Setup as Cabal
import Distribution.Simple.SetupHooks.Internal
import qualified Distribution.Simple.Test as Cabal
import Distribution.Simple.Utils
import Distribution.System (Platform)
import Distribution.Types.BuildType
import Distribution.Types.ComponentRequestedSpec
import qualified Distribution.Types.LocalBuildConfig as LBC
import Distribution.Types.LocalBuildInfo
import Distribution.Utils.Path
  ( makeSymbolicPath
  , relativeSymbolicPath
  )
import Distribution.Verbosity
  ( VerbosityHandles
  , mkVerbosity
  )

import Distribution.Types.HookedBuildInfo (emptyHookedBuildInfo)
import System.Directory (canonicalizePath)

--------------------------------------------------------------------------------
-- Configure

data LibraryConfigureInputs = LibraryConfigureInputs
  { LibraryConfigureInputs -> VerbosityHandles
verbosityHandles :: VerbosityHandles
  , LibraryConfigureInputs -> Compiler
compiler :: Compiler
  , LibraryConfigureInputs -> Platform
platform :: Platform
  , LibraryConfigureInputs -> BuildType
buildType :: BuildType
  , LibraryConfigureInputs -> Maybe ComponentName
compRequested :: Maybe PD.ComponentName
  , LibraryConfigureInputs -> LocalBuildConfig
localBuildConfig :: LBC.LocalBuildConfig
  , LibraryConfigureInputs -> PackageDBStackCWD
packageDBStack :: PackageDBStackCWD
  , LibraryConfigureInputs -> PackageDescription
packageDescription :: PD.PackageDescription
  , LibraryConfigureInputs -> GenericPackageDescription
gPackageDescription :: PD.GenericPackageDescription
  , LibraryConfigureInputs -> FlagAssignment
flagAssignment :: PD.FlagAssignment
  , LibraryConfigureInputs -> InstalledPackageIndex
installedPkgIndex :: InstalledPackageIndex
  }

libraryConfigureInputsFromElabPackage
  :: VerbosityHandles
  -> BuildType
  -> ProgramDb
  -> ElaboratedSharedConfig
  -> ElaboratedReadyPackage
  -> InstalledPackageIndex
  -> [String]
  -- ^ targets
  -> LibraryConfigureInputs
libraryConfigureInputsFromElabPackage :: VerbosityHandles
-> BuildType
-> ProgramDb
-> ElaboratedSharedConfig
-> ElaboratedReadyPackage
-> InstalledPackageIndex
-> [String]
-> LibraryConfigureInputs
libraryConfigureInputsFromElabPackage
  VerbosityHandles
verbHandles
  BuildType
bt
  ProgramDb
progDb
  -- NB: don't use the ProgramDb from the ElaboratedSharedConfig;
  -- that one is only for the compiler itself and not for the package.
  ElaboratedSharedConfig
    { pkgConfigPlatform :: ElaboratedSharedConfig -> Platform
pkgConfigPlatform = Platform
plat
    , pkgConfigCompiler :: ElaboratedSharedConfig -> Compiler
pkgConfigCompiler = Compiler
compil
    }
  (ReadyPackage ElaboratedConfiguredPackage
pkg)
  InstalledPackageIndex
ipi
  [String]
userTargets =
    LibraryConfigureInputs
      { verbosityHandles :: VerbosityHandles
verbosityHandles = VerbosityHandles
verbHandles
      , compiler :: Compiler
compiler = Compiler
compil
      , platform :: Platform
platform = Platform
plat
      , buildType :: BuildType
buildType =
          -- NB: don't get the build-type from 'pkgDescr',
          -- because for Configure build-type we rewrite the build-type
          -- to Simple for components that are neither the main library
          -- nor an executable.
          --
          -- See also 'isMainLibOrExeComponent'.
          BuildType
bt
      , compRequested :: Maybe ComponentName
compRequested =
          case ElaboratedConfiguredPackage -> ElaboratedPackageOrComponent
elabPkgOrComp ElaboratedConfiguredPackage
pkg of
            ElabComponent ElaboratedComponent
elabComp
              | Just ComponentName
elabCompNm <- ElaboratedComponent -> Maybe ComponentName
compComponentName ElaboratedComponent
elabComp ->
                  ComponentName -> Maybe ComponentName
forall a. a -> Maybe a
Just ComponentName
elabCompNm
            ElaboratedPackageOrComponent
_ -> Maybe ComponentName
forall a. Maybe a
Nothing
      , localBuildConfig :: LocalBuildConfig
localBuildConfig =
          LBC.LocalBuildConfig
            { extraConfigArgs :: [String]
LBC.extraConfigArgs = [String]
userTargets
            , withPrograms :: ProgramDb
LBC.withPrograms = ProgramDb
progDb
            , withBuildOptions :: BuildOptions
LBC.withBuildOptions = ElaboratedConfiguredPackage -> BuildOptions
elabBuildOptions ElaboratedConfiguredPackage
pkg
            }
      , packageDBStack :: PackageDBStackCWD
packageDBStack = ElaboratedConfiguredPackage -> PackageDBStackCWD
elabBuildPackageDBStack ElaboratedConfiguredPackage
pkg
      , packageDescription :: PackageDescription
packageDescription = PackageDescription
pkgDescr
      , gPackageDescription :: GenericPackageDescription
gPackageDescription = GenericPackageDescription
gpkgDescr
      , flagAssignment :: FlagAssignment
flagAssignment = ElaboratedConfiguredPackage -> FlagAssignment
elabFlagAssignment ElaboratedConfiguredPackage
pkg
      , installedPkgIndex :: InstalledPackageIndex
installedPkgIndex = InstalledPackageIndex
ipi
      }
    where
      pkgDescr :: PackageDescription
pkgDescr = ElaboratedConfiguredPackage -> PackageDescription
elabPkgDescription ElaboratedConfiguredPackage
pkg
      gpkgDescr :: GenericPackageDescription
gpkgDescr = ElaboratedConfiguredPackage -> GenericPackageDescription
elabGPkgDescription ElaboratedConfiguredPackage
pkg

configure
  :: LibraryConfigureInputs
  -> Cabal.ConfigFlags
  -> IO LocalBuildInfo
configure :: LibraryConfigureInputs -> ConfigFlags -> IO LocalBuildInfo
configure
  LibraryConfigureInputs
    { verbosityHandles :: LibraryConfigureInputs -> VerbosityHandles
verbosityHandles = VerbosityHandles
verbHandles
    , platform :: LibraryConfigureInputs -> Platform
platform = Platform
plat
    , compiler :: LibraryConfigureInputs -> Compiler
compiler = Compiler
compil
    , buildType :: LibraryConfigureInputs -> BuildType
buildType = BuildType
bt
    , compRequested :: LibraryConfigureInputs -> Maybe ComponentName
compRequested = Maybe ComponentName
mbComp
    , localBuildConfig :: LibraryConfigureInputs -> LocalBuildConfig
localBuildConfig = LocalBuildConfig
lbc0
    , packageDBStack :: LibraryConfigureInputs -> PackageDBStackCWD
packageDBStack = PackageDBStackCWD
packageDBs
    , packageDescription :: LibraryConfigureInputs -> PackageDescription
packageDescription = PackageDescription
pkgDescr
    , gPackageDescription :: LibraryConfigureInputs -> GenericPackageDescription
gPackageDescription = GenericPackageDescription
gpkgDescr
    , flagAssignment :: LibraryConfigureInputs -> FlagAssignment
flagAssignment = FlagAssignment
flagAssgn
    , installedPkgIndex :: LibraryConfigureInputs -> InstalledPackageIndex
installedPkgIndex = InstalledPackageIndex
ipi
    }
  ConfigFlags
cfg = do
    -- Here, we essentially want to call the Cabal library 'configure' function,
    -- but skipping over all the steps we don't need such as rediscovering the
    -- compiler or re-resolving the conditionals in the package, as we have done
    -- all of that already.
    --
    -- To achieve this, we call the Cabal 'configureFinal' function which skips
    -- these preparatory steps.
    let verbFlags :: VerbosityFlags
verbFlags = Flag VerbosityFlags -> VerbosityFlags
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag VerbosityFlags -> VerbosityFlags)
-> Flag VerbosityFlags -> VerbosityFlags
forall a b. (a -> b) -> a -> b
$ ConfigFlags -> Flag VerbosityFlags
Cabal.configVerbosity ConfigFlags
cfg
        verbosity :: Verbosity
verbosity = VerbosityHandles -> VerbosityFlags -> Verbosity
mkVerbosity VerbosityHandles
verbHandles VerbosityFlags
verbFlags
        mbWorkDir :: Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir = Flag (SymbolicPath CWD ('Dir Pkg))
-> Maybe (SymbolicPath CWD ('Dir Pkg))
forall a. Flag a -> Maybe a
Cabal.flagToMaybe (Flag (SymbolicPath CWD ('Dir Pkg))
 -> Maybe (SymbolicPath CWD ('Dir Pkg)))
-> Flag (SymbolicPath CWD ('Dir Pkg))
-> Maybe (SymbolicPath CWD ('Dir Pkg))
forall a b. (a -> b) -> a -> b
$ ConfigFlags -> Flag (SymbolicPath CWD ('Dir Pkg))
Cabal.configWorkingDir ConfigFlags
cfg
        distPref :: SymbolicPath Pkg ('Dir Dist)
distPref = Flag (SymbolicPath Pkg ('Dir Dist)) -> SymbolicPath Pkg ('Dir Dist)
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag (SymbolicPath Pkg ('Dir Dist))
 -> SymbolicPath Pkg ('Dir Dist))
-> Flag (SymbolicPath Pkg ('Dir Dist))
-> SymbolicPath Pkg ('Dir Dist)
forall a b. (a -> b) -> a -> b
$ ConfigFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
Cabal.configDistPref ConfigFlags
cfg
        confHooks :: ConfigureHooks
confHooks =
          SetupHooks -> ConfigureHooks
configureHooks (SetupHooks -> ConfigureHooks) -> SetupHooks -> ConfigureHooks
forall a b. (a -> b) -> a -> b
$
            Verbosity
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> SymbolicPath Pkg ('Dir Dist)
-> BuildType
-> SetupHooks
ExternalHooksExe.buildTypeSetupHooks Verbosity
verbosity Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir SymbolicPath Pkg ('Dir Dist)
distPref BuildType
bt

    let pkgId :: PD.PackageIdentifier
        pkgId :: PackageIdentifier
pkgId = PackageDescription -> PackageIdentifier
PD.package PackageDescription
pkgDescr

    -- cabal-install uses paths relative to the current working directory,
    -- while the Cabal library expects symbolic paths. Perform the conversion here
    -- by making the paths absolute.
    packageDBs' <- (PackageDBX String
 -> IO (PackageDBX (SymbolicPath Pkg ('Dir PkgDB))))
-> PackageDBStackCWD
-> IO [PackageDBX (SymbolicPath Pkg ('Dir PkgDB))]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ((String -> IO (SymbolicPath Pkg ('Dir PkgDB)))
-> PackageDBX String
-> IO (PackageDBX (SymbolicPath Pkg ('Dir PkgDB)))
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> PackageDBX a -> f (PackageDBX b)
traverse ((String -> IO (SymbolicPath Pkg ('Dir PkgDB)))
 -> PackageDBX String
 -> IO (PackageDBX (SymbolicPath Pkg ('Dir PkgDB))))
-> (String -> IO (SymbolicPath Pkg ('Dir PkgDB)))
-> PackageDBX String
-> IO (PackageDBX (SymbolicPath Pkg ('Dir PkgDB)))
forall a b. (a -> b) -> a -> b
$ (String -> SymbolicPath Pkg ('Dir PkgDB))
-> IO String -> IO (SymbolicPath Pkg ('Dir PkgDB))
forall a b. (a -> b) -> IO a -> IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap String -> SymbolicPath Pkg ('Dir PkgDB)
forall from (to :: FileOrDir). String -> SymbolicPath from to
makeSymbolicPath (IO String -> IO (SymbolicPath Pkg ('Dir PkgDB)))
-> (String -> IO String)
-> String
-> IO (SymbolicPath Pkg ('Dir PkgDB))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> IO String
canonicalizePath) PackageDBStackCWD
packageDBs

    -- Configure package
    case mbComp of
      Maybe ComponentName
Nothing -> Verbosity -> String -> PackageIdentifier -> IO ()
setupMessage Verbosity
verbosity String
"Configuring" PackageIdentifier
pkgId
      Just ComponentName
cname ->
        Verbosity
-> String
-> PackageIdentifier
-> ComponentName
-> Maybe [(ModuleName, Module)]
-> IO ()
forall a.
Pretty a =>
Verbosity
-> String
-> PackageIdentifier
-> ComponentName
-> Maybe [(ModuleName, a)]
-> IO ()
setupMessage'
          Verbosity
verbosity
          String
"Configuring"
          PackageIdentifier
pkgId
          ComponentName
cname
          ([(ModuleName, Module)] -> Maybe [(ModuleName, Module)]
forall a. a -> Maybe a
Just (ConfigFlags -> [(ModuleName, Module)]
Cabal.configInstantiateWith ConfigFlags
cfg))

    -- TODO: we should implement recompilation checking on the level of
    -- individual components, so that we only re-configure the components that
    -- need reconfiguring (including running their hooks). See #11761.
    lbc1 <- case preConfPackageHook confHooks of
      Maybe PreConfPackageHook
Nothing -> LocalBuildConfig -> IO LocalBuildConfig
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return LocalBuildConfig
lbc0
      Just PreConfPackageHook
hk -> ConfigFlags
-> Compiler
-> Platform
-> LocalBuildConfig
-> PreConfPackageHook
-> IO LocalBuildConfig
Cabal.runPreConfPackageHook ConfigFlags
cfg Compiler
compil Platform
plat LocalBuildConfig
lbc0 PreConfPackageHook
hk
    let compRequestedSpec = case Maybe ComponentName
mbComp of
          Just ComponentName
compName -> ComponentName -> ComponentRequestedSpec
OneComponentRequestedSpec ComponentName
compName
          Maybe ComponentName
Nothing ->
            ComponentRequestedSpec
              { testsRequested :: Bool
testsRequested = Flag Bool -> Bool
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (ConfigFlags -> Flag Bool
Cabal.configTests ConfigFlags
cfg)
              , benchmarksRequested :: Bool
benchmarksRequested = Flag Bool -> Bool
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (ConfigFlags -> Flag Bool
Cabal.configBenchmarks ConfigFlags
cfg)
              }

    -- NB: it's OK to discard constraints here: we already have a finalized PackageDescription
    -- in hand, and we are using exact UnitIds for all dependencies (this corresponds
    -- to using --exact-configuration and --dependency flags with the Setup CLI).
    (_allConstraints, pkgInfo) <-
      -- Use cabal-install's running InstalledPackageIndex 'ipi' to skip over
      -- having to invoke ghc-pkg once per package.
      --
      -- See (ProjIPI3) from Note [Per-project InstalledPackageIndex]
      -- in Distribution.Client.ProjectBuilding.
      Cabal.computePackageInfoFromIndex verbHandles cfg gpkgDescr ipi

    -- Post-configure hooks & per-component configure
    lbi1 <-
      Cabal.configureFinal
        verbHandles
        confHooks
        emptyHookedBuildInfo
        cfg
        lbc1
        (gpkgDescr, pkgDescr)
        flagAssgn
        compRequestedSpec
        compil
        plat
        packageDBs'
        pkgInfo

    -- Remember the .cabal filename if we know it.
    pkgDescrFilePath <-
      case Cabal.flagToMaybe $ Cabal.configCabalFilePath cfg of
        Just SymbolicPath Pkg 'File
pkgFile -> SymbolicPath Pkg 'File -> IO (SymbolicPath Pkg 'File)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return SymbolicPath Pkg 'File
pkgFile
        Maybe (SymbolicPath Pkg 'File)
Nothing -> RelativePath Pkg 'File -> SymbolicPath Pkg 'File
forall from (to :: FileOrDir).
RelativePath from to -> SymbolicPath from to
relativeSymbolicPath (RelativePath Pkg 'File -> SymbolicPath Pkg 'File)
-> IO (RelativePath Pkg 'File) -> IO (SymbolicPath Pkg 'File)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Verbosity
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> IO (RelativePath Pkg 'File)
tryFindPackageDesc Verbosity
verbosity Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir
    return $ lbi1{pkgDescrFile = Just pkgDescrFilePath}

--------------------------------------------------------------------------------
-- Build

build
  :: VerbosityHandles
  -> Cabal.BuildFlags
  -> LocalBuildInfo
  -> [String]
  -> IO [MonitorFilePath]
build :: VerbosityHandles
-> BuildFlags -> LocalBuildInfo -> [String] -> IO [MonitorFilePath]
build VerbosityHandles
verbHandles BuildFlags
flags LocalBuildInfo
lbi [String]
_args =
  (PreBuildComponentInputs -> IO [MonitorFilePath],
 PostBuildComponentInputs -> IO ())
-> VerbosityHandles
-> PackageDescription
-> LocalBuildInfo
-> BuildFlags
-> [PPSuffixHandler]
-> IO [MonitorFilePath]
build_setupHooks (PreBuildComponentInputs -> IO [MonitorFilePath]
preBuildHook, PostBuildComponentInputs -> IO ()
postBuildHook) VerbosityHandles
verbHandles PackageDescription
pkgDescr LocalBuildInfo
lbi BuildFlags
flags [PPSuffixHandler]
Cabal.knownSuffixHandlers
  where
    verb :: Verbosity
verb = VerbosityHandles -> VerbosityFlags -> Verbosity
mkVerbosity VerbosityHandles
verbHandles (VerbosityFlags -> Verbosity) -> VerbosityFlags -> Verbosity
forall a b. (a -> b) -> a -> b
$ Flag VerbosityFlags -> VerbosityFlags
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag VerbosityFlags -> VerbosityFlags)
-> Flag VerbosityFlags -> VerbosityFlags
forall a b. (a -> b) -> a -> b
$ BuildFlags -> Flag VerbosityFlags
Cabal.buildVerbosity BuildFlags
flags
    hooks :: SetupHooks
hooks = Verbosity
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> SymbolicPath Pkg ('Dir Dist)
-> BuildType
-> SetupHooks
ExternalHooksExe.buildTypeSetupHooks Verbosity
verb Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir SymbolicPath Pkg ('Dir Dist)
distPref BuildType
bt
    -- (Recall that pre-build hooks are treated specially;
    -- see the 'buildTypeSetupHooks' and 'buildTypePreBuildHooks' functions.)
    preBuildHook :: PreBuildComponentInputs -> IO [MonitorFilePath]
preBuildHook = VerbosityHandles
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> SymbolicPath Pkg ('Dir Dist)
-> BuildType
-> PreBuildComponentInputs
-> IO [MonitorFilePath]
ExternalHooksExe.buildTypePreBuildHooks VerbosityHandles
verbHandles Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir SymbolicPath Pkg ('Dir Dist)
distPref BuildType
bt
    postBuildHook :: PostBuildComponentInputs -> IO ()
postBuildHook
      | Just PostBuildComponentInputs -> IO ()
postBuild <- BuildHooks -> Maybe (PostBuildComponentInputs -> IO ())
postBuildComponentHook (BuildHooks -> Maybe (PostBuildComponentInputs -> IO ()))
-> BuildHooks -> Maybe (PostBuildComponentInputs -> IO ())
forall a b. (a -> b) -> a -> b
$ SetupHooks -> BuildHooks
buildHooks SetupHooks
hooks =
          PostBuildComponentInputs -> IO ()
postBuild
      | Bool
otherwise =
          IO () -> PostBuildComponentInputs -> IO ()
forall a b. a -> b -> a
const (IO () -> PostBuildComponentInputs -> IO ())
-> IO () -> PostBuildComponentInputs -> IO ()
forall a b. (a -> b) -> a -> b
$ () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi
    bt :: BuildType
bt = PackageDescription -> BuildType
PD.buildType PackageDescription
pkgDescr
    mbWorkDir :: Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir = LocalBuildInfo -> Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDirLBI LocalBuildInfo
lbi
    distPref :: SymbolicPath Pkg ('Dir Dist)
distPref = Flag (SymbolicPath Pkg ('Dir Dist)) -> SymbolicPath Pkg ('Dir Dist)
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag (SymbolicPath Pkg ('Dir Dist))
 -> SymbolicPath Pkg ('Dir Dist))
-> Flag (SymbolicPath Pkg ('Dir Dist))
-> SymbolicPath Pkg ('Dir Dist)
forall a b. (a -> b) -> a -> b
$ BuildFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
Cabal.buildDistPref BuildFlags
flags

--------------------------------------------------------------------------------
-- Haddock

haddock
  :: VerbosityHandles
  -> Cabal.HaddockFlags
  -> LocalBuildInfo
  -> [String]
  -> IO [MonitorFilePath]
haddock :: VerbosityHandles
-> HaddockFlags
-> LocalBuildInfo
-> [String]
-> IO [MonitorFilePath]
haddock VerbosityHandles
verbHandles HaddockFlags
flags LocalBuildInfo
lbi [String]
_args =
  (PreBuildComponentInputs -> IO [MonitorFilePath])
-> VerbosityHandles
-> PackageDescription
-> LocalBuildInfo
-> [PPSuffixHandler]
-> HaddockFlags
-> IO [MonitorFilePath]
haddock_setupHooks PreBuildComponentInputs -> IO [MonitorFilePath]
preBuildHook VerbosityHandles
verbHandles PackageDescription
pkgDescr LocalBuildInfo
lbi [PPSuffixHandler]
Cabal.knownSuffixHandlers HaddockFlags
flags
  where
    preBuildHook :: PreBuildComponentInputs -> IO [MonitorFilePath]
preBuildHook = VerbosityHandles
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> SymbolicPath Pkg ('Dir Dist)
-> BuildType
-> PreBuildComponentInputs
-> IO [MonitorFilePath]
ExternalHooksExe.buildTypePreBuildHooks VerbosityHandles
verbHandles Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir SymbolicPath Pkg ('Dir Dist)
distPref BuildType
bt
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi
    bt :: BuildType
bt = PackageDescription -> BuildType
PD.buildType PackageDescription
pkgDescr
    mbWorkDir :: Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir = LocalBuildInfo -> Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDirLBI LocalBuildInfo
lbi
    distPref :: SymbolicPath Pkg ('Dir Dist)
distPref = Flag (SymbolicPath Pkg ('Dir Dist)) -> SymbolicPath Pkg ('Dir Dist)
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag (SymbolicPath Pkg ('Dir Dist))
 -> SymbolicPath Pkg ('Dir Dist))
-> Flag (SymbolicPath Pkg ('Dir Dist))
-> SymbolicPath Pkg ('Dir Dist)
forall a b. (a -> b) -> a -> b
$ HaddockFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
Cabal.haddockDistPref HaddockFlags
flags

--------------------------------------------------------------------------------
-- Repl

repl
  :: VerbosityHandles
  -> Cabal.ReplFlags
  -> LocalBuildInfo
  -> [String]
  -> IO [MonitorFilePath]
repl :: VerbosityHandles
-> ReplFlags -> LocalBuildInfo -> [String] -> IO [MonitorFilePath]
repl VerbosityHandles
verbHandles ReplFlags
flags LocalBuildInfo
lbi [String]
_args =
  (PreBuildComponentInputs -> IO [MonitorFilePath])
-> VerbosityHandles
-> PackageDescription
-> LocalBuildInfo
-> ReplFlags
-> [PPSuffixHandler]
-> [String]
-> IO [MonitorFilePath]
repl_setupHooks PreBuildComponentInputs -> IO [MonitorFilePath]
preBuildHook VerbosityHandles
verbHandles PackageDescription
pkgDescr LocalBuildInfo
lbi ReplFlags
flags [PPSuffixHandler]
Cabal.knownSuffixHandlers []
  where
    preBuildHook :: PreBuildComponentInputs -> IO [MonitorFilePath]
preBuildHook = VerbosityHandles
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> SymbolicPath Pkg ('Dir Dist)
-> BuildType
-> PreBuildComponentInputs
-> IO [MonitorFilePath]
ExternalHooksExe.buildTypePreBuildHooks VerbosityHandles
verbHandles Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir SymbolicPath Pkg ('Dir Dist)
distPref BuildType
bt
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi
    bt :: BuildType
bt = PackageDescription -> BuildType
PD.buildType PackageDescription
pkgDescr
    mbWorkDir :: Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir = LocalBuildInfo -> Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDirLBI LocalBuildInfo
lbi
    distPref :: SymbolicPath Pkg ('Dir Dist)
distPref = Flag (SymbolicPath Pkg ('Dir Dist)) -> SymbolicPath Pkg ('Dir Dist)
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag (SymbolicPath Pkg ('Dir Dist))
 -> SymbolicPath Pkg ('Dir Dist))
-> Flag (SymbolicPath Pkg ('Dir Dist))
-> SymbolicPath Pkg ('Dir Dist)
forall a b. (a -> b) -> a -> b
$ ReplFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
Cabal.replDistPref ReplFlags
flags

--------------------------------------------------------------------------------
-- Copy

copy
  :: VerbosityHandles
  -> Cabal.CopyFlags
  -> LocalBuildInfo
  -> [String]
  -> IO ()
copy :: VerbosityHandles
-> CopyFlags -> LocalBuildInfo -> [String] -> IO ()
copy VerbosityHandles
verbHandles CopyFlags
flags LocalBuildInfo
lbi [String]
_args =
  InstallHooks
-> VerbosityHandles
-> PackageDescription
-> LocalBuildInfo
-> CopyFlags
-> IO ()
install_setupHooks InstallHooks
hooks VerbosityHandles
verbHandles PackageDescription
pkgDescr LocalBuildInfo
lbi CopyFlags
flags
  where
    verb :: Verbosity
verb = VerbosityHandles -> VerbosityFlags -> Verbosity
mkVerbosity VerbosityHandles
verbHandles (VerbosityFlags -> Verbosity) -> VerbosityFlags -> Verbosity
forall a b. (a -> b) -> a -> b
$ Flag VerbosityFlags -> VerbosityFlags
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag VerbosityFlags -> VerbosityFlags)
-> Flag VerbosityFlags -> VerbosityFlags
forall a b. (a -> b) -> a -> b
$ CopyFlags -> Flag VerbosityFlags
Cabal.copyVerbosity CopyFlags
flags
    hooks :: InstallHooks
hooks = SetupHooks -> InstallHooks
installHooks (SetupHooks -> InstallHooks) -> SetupHooks -> InstallHooks
forall a b. (a -> b) -> a -> b
$ Verbosity
-> Maybe (SymbolicPath CWD ('Dir Pkg))
-> SymbolicPath Pkg ('Dir Dist)
-> BuildType
-> SetupHooks
ExternalHooksExe.buildTypeSetupHooks Verbosity
verb Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir SymbolicPath Pkg ('Dir Dist)
distPref BuildType
bt
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi
    bt :: BuildType
bt = PackageDescription -> BuildType
PD.buildType PackageDescription
pkgDescr
    mbWorkDir :: Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDir = LocalBuildInfo -> Maybe (SymbolicPath CWD ('Dir Pkg))
mbWorkDirLBI LocalBuildInfo
lbi
    distPref :: SymbolicPath Pkg ('Dir Dist)
distPref = Flag (SymbolicPath Pkg ('Dir Dist)) -> SymbolicPath Pkg ('Dir Dist)
forall a. WithCallStack (Flag a -> a)
Cabal.fromFlag (Flag (SymbolicPath Pkg ('Dir Dist))
 -> SymbolicPath Pkg ('Dir Dist))
-> Flag (SymbolicPath Pkg ('Dir Dist))
-> SymbolicPath Pkg ('Dir Dist)
forall a b. (a -> b) -> a -> b
$ CopyFlags -> Flag (SymbolicPath Pkg ('Dir Dist))
Cabal.copyDistPref CopyFlags
flags

--------------------------------------------------------------------------------
-- Test, bench, register.
--
-- NB: no hooks into these phases.

test
  :: VerbosityHandles
  -> Cabal.TestFlags
  -> LocalBuildInfo
  -> [String]
  -> IO ()
test :: VerbosityHandles
-> TestFlags -> LocalBuildInfo -> [String] -> IO ()
test VerbosityHandles
verb TestFlags
flags LocalBuildInfo
lbi [String]
args =
  [String]
-> VerbosityHandles
-> PackageDescription
-> LocalBuildInfo
-> TestFlags
-> IO ()
Cabal.test [String]
args VerbosityHandles
verb PackageDescription
pkgDescr LocalBuildInfo
lbi TestFlags
flags
  where
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi

bench
  :: VerbosityHandles
  -> Cabal.BenchmarkFlags
  -> LocalBuildInfo
  -> [String]
  -> IO ()
bench :: VerbosityHandles
-> BenchmarkFlags -> LocalBuildInfo -> [String] -> IO ()
bench VerbosityHandles
verb BenchmarkFlags
flags LocalBuildInfo
lbi [String]
args =
  [String]
-> VerbosityHandles
-> PackageDescription
-> LocalBuildInfo
-> BenchmarkFlags
-> IO ()
Cabal.bench [String]
args VerbosityHandles
verb PackageDescription
pkgDescr LocalBuildInfo
lbi BenchmarkFlags
flags
  where
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi

register
  :: Cabal.RegisterFlags
  -> LocalBuildInfo
  -> [String]
  -> IO ()
register :: RegisterFlags -> LocalBuildInfo -> [String] -> IO ()
register RegisterFlags
flags LocalBuildInfo
lbi [String]
_args = PackageDescription -> LocalBuildInfo -> RegisterFlags -> IO ()
Cabal.register PackageDescription
pkgDescr LocalBuildInfo
lbi RegisterFlags
flags
  where
    pkgDescr :: PackageDescription
pkgDescr = LocalBuildInfo -> PackageDescription
localPkgDescr LocalBuildInfo
lbi