{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE TupleSections #-}

-- | cabal-install CLI command: run
--
module Distribution.Client.CmdRun (
    -- * The @run@ CLI and action
    runCommand,
    runAction,
    handleShebang, validScript,

    -- * Internals exposed for testing
    matchesMultipleProblem,
    noExesProblem,
    selectPackageTargets,
    selectComponentTarget
  ) where

import Prelude ()
import Distribution.Client.Compat.Prelude hiding (toList)

import Distribution.Client.ProjectOrchestration
import Distribution.Client.CmdErrorMessages
         ( renderTargetSelector, showTargetSelector,
           renderTargetProblem,
           renderTargetProblemNoTargets, plural, targetSelectorPluralPkgs,
           targetSelectorFilter, renderListCommaAnd )
import Distribution.Client.TargetProblem
         ( TargetProblem (..) )

import Distribution.Client.NixStyleOptions
         ( NixStyleFlags (..), nixStyleOptions, defaultNixStyleFlags )
import Distribution.Client.Setup
         ( GlobalFlags(..), ConfigFlags(..) )
import Distribution.Client.GlobalFlags
         ( defaultGlobalFlags )
import Distribution.Simple.Flag
         ( fromFlagOrDefault )
import Distribution.Simple.Command
         ( CommandUI(..), usageAlternatives )
import Distribution.Types.ComponentName
         ( showComponentName )
import Distribution.Verbosity
         ( normal, silent )
import Distribution.Simple.Utils
         ( wrapText, die', info, notice )
import Distribution.Client.ProjectPlanning
         ( ElaboratedConfiguredPackage(..)
         , ElaboratedInstallPlan, binDirectoryFor )
import Distribution.Client.ProjectPlanning.Types
         ( dataDirsEnvironmentForPlan )
import Distribution.Client.InstallPlan
         ( toList, foldPlanPackage )
import Distribution.Types.UnqualComponentName
         ( UnqualComponentName, unUnqualComponentName )
import Distribution.Simple.Program.Run
         ( runProgramInvocation, ProgramInvocation(..),
           emptyProgramInvocation )
import Distribution.Types.UnitId
         ( UnitId )
import Distribution.Client.ScriptUtils
         ( AcceptNoTargets(..), withContextAndSelectors, updateContextAndWriteProjectFile, TargetContext(..) )

import qualified Data.Set as Set
import System.Directory
         ( doesFileExist )
import System.FilePath
         ( (</>), isValid, isPathSeparator )

runCommand :: CommandUI (NixStyleFlags ())
runCommand :: CommandUI (NixStyleFlags ())
runCommand = CommandUI :: forall flags.
String
-> String
-> (String -> String)
-> Maybe (String -> String)
-> Maybe (String -> String)
-> flags
-> (ShowOrParseArgs -> [OptionField flags])
-> CommandUI flags
CommandUI
  { commandName :: String
commandName         = String
"v2-run"
  , commandSynopsis :: String
commandSynopsis     = String
"Run an executable."
  , commandUsage :: String -> String
commandUsage        = String -> [String] -> String -> String
usageAlternatives String
"v2-run"
                          [ String
"[TARGET] [FLAGS] [-- EXECUTABLE_FLAGS]" ]
  , commandDescription :: Maybe (String -> String)
commandDescription  = (String -> String) -> Maybe (String -> String)
forall a. a -> Maybe a
Just ((String -> String) -> Maybe (String -> String))
-> (String -> String) -> Maybe (String -> String)
forall a b. (a -> b) -> a -> b
$ \String
pname -> String -> String
wrapText (String -> String) -> String -> String
forall a b. (a -> b) -> a -> b
$
         String
"Runs the specified executable-like component (an executable, a test, "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"or a benchmark), first ensuring it is up to date.\n\n"

      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Any executable-like component in any package in the project can be "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"specified. A package can be specified if contains just one "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"executable-like, preferring a single executable. The default is to "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"use the package in the current directory if it contains just one "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"executable-like.\n\n"

      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Extra arguments can be passed to the program, but use '--' to "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"separate arguments for the program from arguments for " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
". The executable is run in an environment where it can find its "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"data files inplace in the build tree.\n\n"

      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"Dependencies are built or rebuilt as necessary. Additional "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"configuration flags can be specified on the command line and these "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"extend the project configuration from the 'cabal.project', "
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'cabal.project.local' and other files."
  , commandNotes :: Maybe (String -> String)
commandNotes        = (String -> String) -> Maybe (String -> String)
forall a. a -> Maybe a
Just ((String -> String) -> Maybe (String -> String))
-> (String -> String) -> Maybe (String -> String)
forall a b. (a -> b) -> a -> b
$ \String
pname ->
         String
"Examples:\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"  " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"    Run the executable-like in the package in the current directory\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"  " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run foo-tool\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"    Run the named executable-like (in any package in the project)\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"  " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run pkgfoo:foo-tool\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"    Run the executable-like 'foo-tool' in the package 'pkgfoo'\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"  " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
pname String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" v2-run foo -O2 -- dothing --fooflag\n"
      String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"    Build with '-O2' and run the program, passing it extra arguments.\n"

  , commandDefaultFlags :: NixStyleFlags ()
commandDefaultFlags = () -> NixStyleFlags ()
forall a. a -> NixStyleFlags a
defaultNixStyleFlags ()
  , commandOptions :: ShowOrParseArgs -> [OptionField (NixStyleFlags ())]
commandOptions      = (ShowOrParseArgs -> [OptionField ()])
-> ShowOrParseArgs -> [OptionField (NixStyleFlags ())]
forall a.
(ShowOrParseArgs -> [OptionField a])
-> ShowOrParseArgs -> [OptionField (NixStyleFlags a)]
nixStyleOptions ([OptionField ()] -> ShowOrParseArgs -> [OptionField ()]
forall a b. a -> b -> a
const [])
  }

-- | The @run@ command runs a specified executable-like component, building it
-- first if necessary. The component can be either an executable, a test,
-- or a benchmark. This is particularly useful for passing arguments to
-- exes/tests/benchs by simply appending them after a @--@.
--
-- For more details on how this works, see the module
-- "Distribution.Client.ProjectOrchestration"
--
runAction :: NixStyleFlags () -> [String] -> GlobalFlags -> IO ()
runAction :: NixStyleFlags () -> [String] -> GlobalFlags -> IO ()
runAction flags :: NixStyleFlags ()
flags@NixStyleFlags {()
ConfigFlags
HaddockFlags
TestFlags
BenchmarkFlags
ProjectFlags
InstallFlags
ConfigExFlags
extraFlags :: forall a. NixStyleFlags a -> a
projectFlags :: forall a. NixStyleFlags a -> ProjectFlags
benchmarkFlags :: forall a. NixStyleFlags a -> BenchmarkFlags
testFlags :: forall a. NixStyleFlags a -> TestFlags
haddockFlags :: forall a. NixStyleFlags a -> HaddockFlags
installFlags :: forall a. NixStyleFlags a -> InstallFlags
configExFlags :: forall a. NixStyleFlags a -> ConfigExFlags
configFlags :: forall a. NixStyleFlags a -> ConfigFlags
extraFlags :: ()
projectFlags :: ProjectFlags
benchmarkFlags :: BenchmarkFlags
testFlags :: TestFlags
haddockFlags :: HaddockFlags
installFlags :: InstallFlags
configExFlags :: ConfigExFlags
configFlags :: ConfigFlags
..} [String]
targetAndArgs GlobalFlags
globalFlags
  = AcceptNoTargets
-> Maybe ComponentKind
-> NixStyleFlags ()
-> [String]
-> GlobalFlags
-> (TargetContext
    -> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ()
forall a b.
AcceptNoTargets
-> Maybe ComponentKind
-> NixStyleFlags a
-> [String]
-> GlobalFlags
-> (TargetContext
    -> ProjectBaseContext -> [TargetSelector] -> IO b)
-> IO b
withContextAndSelectors AcceptNoTargets
RejectNoTargets (ComponentKind -> Maybe ComponentKind
forall a. a -> Maybe a
Just ComponentKind
ExeKind) NixStyleFlags ()
flags [String]
targetStr GlobalFlags
globalFlags ((TargetContext -> ProjectBaseContext -> [TargetSelector] -> IO ())
 -> IO ())
-> (TargetContext
    -> ProjectBaseContext -> [TargetSelector] -> IO ())
-> IO ()
forall a b. (a -> b) -> a -> b
$ \TargetContext
targetCtx ProjectBaseContext
ctx [TargetSelector]
targetSelectors -> do
    (ProjectBaseContext
baseCtx, Verbosity
defaultVerbosity) <- case TargetContext
targetCtx of
      TargetContext
ProjectContext             -> (ProjectBaseContext, Verbosity)
-> IO (ProjectBaseContext, Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectBaseContext
ctx, Verbosity
normal)
      TargetContext
GlobalContext              -> (ProjectBaseContext, Verbosity)
-> IO (ProjectBaseContext, Verbosity)
forall (m :: * -> *) a. Monad m => a -> m a
return (ProjectBaseContext
ctx, Verbosity
normal)
      ScriptContext String
path Executable
exemeta -> (, Verbosity
silent) (ProjectBaseContext -> (ProjectBaseContext, Verbosity))
-> IO ProjectBaseContext -> IO (ProjectBaseContext, Verbosity)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ProjectBaseContext -> String -> Executable -> IO ProjectBaseContext
updateContextAndWriteProjectFile ProjectBaseContext
ctx String
path Executable
exemeta

    let verbosity :: Verbosity
verbosity = Verbosity -> Flag Verbosity -> Verbosity
forall a. a -> Flag a -> a
fromFlagOrDefault Verbosity
defaultVerbosity (ConfigFlags -> Flag Verbosity
configVerbosity ConfigFlags
configFlags)

    ProjectBuildContext
buildCtx <-
      Verbosity
-> ProjectBaseContext
-> (ElaboratedInstallPlan
    -> IO (ElaboratedInstallPlan, TargetsMap))
-> IO ProjectBuildContext
runProjectPreBuildPhase Verbosity
verbosity ProjectBaseContext
baseCtx ((ElaboratedInstallPlan -> IO (ElaboratedInstallPlan, TargetsMap))
 -> IO ProjectBuildContext)
-> (ElaboratedInstallPlan
    -> IO (ElaboratedInstallPlan, TargetsMap))
-> IO ProjectBuildContext
forall a b. (a -> b) -> a -> b
$ \ElaboratedInstallPlan
elaboratedPlan -> do

            Bool -> IO () -> IO ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (BuildTimeSettings -> Bool
buildSettingOnlyDeps (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)) (IO () -> IO ()) -> IO () -> IO ()
forall a b. (a -> b) -> a -> b
$
              Verbosity -> String -> IO ()
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$
                  String
"The run command does not support '--only-dependencies'. "
               String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"You may wish to use 'build --only-dependencies' and then "
               String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"use 'run'."

            -- Interpret the targets on the command line as build targets
            -- (as opposed to say repl or haddock targets).
            TargetsMap
targets <- ([RunTargetProblem] -> IO TargetsMap)
-> (TargetsMap -> IO TargetsMap)
-> Either [RunTargetProblem] TargetsMap
-> IO TargetsMap
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (Verbosity -> [RunTargetProblem] -> IO TargetsMap
forall a. Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems Verbosity
verbosity) TargetsMap -> IO TargetsMap
forall (m :: * -> *) a. Monad m => a -> m a
return
                     (Either [RunTargetProblem] TargetsMap -> IO TargetsMap)
-> Either [RunTargetProblem] TargetsMap -> IO TargetsMap
forall a b. (a -> b) -> a -> b
$ (forall k.
 TargetSelector
 -> [AvailableTarget k] -> Either RunTargetProblem [k])
-> (forall k.
    SubComponentTarget
    -> AvailableTarget k -> Either RunTargetProblem k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [RunTargetProblem] TargetsMap
forall err.
(forall k.
 TargetSelector
 -> [AvailableTarget k] -> Either (TargetProblem err) [k])
-> (forall k.
    SubComponentTarget
    -> AvailableTarget k -> Either (TargetProblem err) k)
-> ElaboratedInstallPlan
-> Maybe SourcePackageDb
-> [TargetSelector]
-> Either [TargetProblem err] TargetsMap
resolveTargets
                         forall k.
TargetSelector
-> [AvailableTarget k] -> Either RunTargetProblem [k]
selectPackageTargets
                         forall k.
SubComponentTarget
-> AvailableTarget k -> Either RunTargetProblem k
selectComponentTarget
                         ElaboratedInstallPlan
elaboratedPlan
                         Maybe SourcePackageDb
forall a. Maybe a
Nothing
                         [TargetSelector]
targetSelectors

            -- Reject multiple targets, or at least targets in different
            -- components. It is ok to have two module/file targets in the
            -- same component, but not two that live in different components.
            --
            -- Note that we discard the target and return the whole 'TargetsMap',
            -- so this check will be repeated (and must succeed) after
            -- the 'runProjectPreBuildPhase'. Keep it in mind when modifying this.
            (UnitId, UnqualComponentName)
_ <- IO (UnitId, UnqualComponentName)
-> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse
                   (Verbosity -> [RunTargetProblem] -> IO (UnitId, UnqualComponentName)
forall a. Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems
                      Verbosity
verbosity
                      [TargetsMap -> RunTargetProblem
multipleTargetsProblem TargetsMap
targets])
                   TargetsMap
targets

            let elaboratedPlan' :: ElaboratedInstallPlan
elaboratedPlan' = TargetAction
-> TargetsMap -> ElaboratedInstallPlan -> ElaboratedInstallPlan
pruneInstallPlanToTargets
                                    TargetAction
TargetActionBuild
                                    TargetsMap
targets
                                    ElaboratedInstallPlan
elaboratedPlan
            (ElaboratedInstallPlan, TargetsMap)
-> IO (ElaboratedInstallPlan, TargetsMap)
forall (m :: * -> *) a. Monad m => a -> m a
return (ElaboratedInstallPlan
elaboratedPlan', TargetsMap
targets)

    (UnitId
selectedUnitId, UnqualComponentName
selectedComponent) <-
      -- Slight duplication with 'runProjectPreBuildPhase'.
      IO (UnitId, UnqualComponentName)
-> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse
        (Verbosity -> String -> IO (UnitId, UnqualComponentName)
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO (UnitId, UnqualComponentName))
-> String -> IO (UnitId, UnqualComponentName)
forall a b. (a -> b) -> a -> b
$ String
"No or multiple targets given, but the run "
                       String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"phase has been reached. This is a bug.")
        (TargetsMap -> IO (UnitId, UnqualComponentName))
-> TargetsMap -> IO (UnitId, UnqualComponentName)
forall a b. (a -> b) -> a -> b
$ ProjectBuildContext -> TargetsMap
targetsMap ProjectBuildContext
buildCtx

    Verbosity -> ProjectBaseContext -> ProjectBuildContext -> IO ()
printPlan Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx

    BuildOutcomes
buildOutcomes <- Verbosity
-> ProjectBaseContext -> ProjectBuildContext -> IO BuildOutcomes
runProjectBuildPhase Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx
    Verbosity
-> ProjectBaseContext
-> ProjectBuildContext
-> BuildOutcomes
-> IO ()
runProjectPostBuildPhase Verbosity
verbosity ProjectBaseContext
baseCtx ProjectBuildContext
buildCtx BuildOutcomes
buildOutcomes


    let elaboratedPlan :: ElaboratedInstallPlan
elaboratedPlan = ProjectBuildContext -> ElaboratedInstallPlan
elaboratedPlanToExecute ProjectBuildContext
buildCtx
        matchingElaboratedConfiguredPackages :: [ElaboratedConfiguredPackage]
matchingElaboratedConfiguredPackages =
          UnitId -> ElaboratedInstallPlan -> [ElaboratedConfiguredPackage]
matchingPackagesByUnitId
            UnitId
selectedUnitId
            ElaboratedInstallPlan
elaboratedPlan

    let exeName :: String
exeName = UnqualComponentName -> String
unUnqualComponentName UnqualComponentName
selectedComponent

    -- In the common case, we expect @matchingElaboratedConfiguredPackages@
    -- to consist of a single element that provides a single way of building
    -- an appropriately-named executable. In that case we take that
    -- package and continue.
    --
    -- However, multiple packages/components could provide that
    -- executable, or it's possible we don't find the executable anywhere
    -- in the build plan. I suppose in principle it's also possible that
    -- a single package provides an executable in two different ways,
    -- though that's probably a bug if. Anyway it's a good lint to report
    -- an error in all of these cases, even if some seem like they
    -- shouldn't happen.
    ElaboratedConfiguredPackage
pkg <- case [ElaboratedConfiguredPackage]
matchingElaboratedConfiguredPackages of
      [] -> Verbosity -> String -> IO ElaboratedConfiguredPackage
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO ElaboratedConfiguredPackage)
-> String -> IO ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$ String
"Unknown executable "
                          String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exeName
                          String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" in package "
                          String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnitId -> String
forall a. Pretty a => a -> String
prettyShow UnitId
selectedUnitId
      [ElaboratedConfiguredPackage
elabPkg] -> do
        Verbosity -> String -> IO ()
info Verbosity
verbosity (String -> IO ()) -> String -> IO ()
forall a b. (a -> b) -> a -> b
$ String
"Selecting "
                       String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnitId -> String
forall a. Pretty a => a -> String
prettyShow UnitId
selectedUnitId
                       String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" to supply " String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exeName
        ElaboratedConfiguredPackage -> IO ElaboratedConfiguredPackage
forall (m :: * -> *) a. Monad m => a -> m a
return ElaboratedConfiguredPackage
elabPkg
      [ElaboratedConfiguredPackage]
elabPkgs -> Verbosity -> String -> IO ElaboratedConfiguredPackage
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity
        (String -> IO ElaboratedConfiguredPackage)
-> String -> IO ElaboratedConfiguredPackage
forall a b. (a -> b) -> a -> b
$ String
"Multiple matching executables found matching "
        String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
exeName
        String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
":\n"
        String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
unlines ((ElaboratedConfiguredPackage -> String)
-> [ElaboratedConfiguredPackage] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\ElaboratedConfiguredPackage
p -> String
" - in package " String -> String -> String
forall a. [a] -> [a] -> [a]
++ UnitId -> String
forall a. Pretty a => a -> String
prettyShow (ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
p)) [ElaboratedConfiguredPackage]
elabPkgs)
    let exePath :: String
exePath = DistDirLayout
-> ElaboratedSharedConfig
-> ElaboratedConfiguredPackage
-> String
-> String
binDirectoryFor (ProjectBaseContext -> DistDirLayout
distDirLayout ProjectBaseContext
baseCtx)
                                  (ProjectBuildContext -> ElaboratedSharedConfig
elaboratedShared ProjectBuildContext
buildCtx)
                                  ElaboratedConfiguredPackage
pkg
                                  String
exeName
               String -> String -> String
</> String
exeName
    let dryRun :: Bool
dryRun = BuildTimeSettings -> Bool
buildSettingDryRun (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)
              Bool -> Bool -> Bool
|| BuildTimeSettings -> Bool
buildSettingOnlyDownload (ProjectBaseContext -> BuildTimeSettings
buildSettings ProjectBaseContext
baseCtx)

    if Bool
dryRun
       then Verbosity -> String -> IO ()
notice Verbosity
verbosity String
"Running of executable suppressed by flag(s)"
       else
         Verbosity -> ProgramInvocation -> IO ()
runProgramInvocation
           Verbosity
verbosity
           ProgramInvocation
emptyProgramInvocation {
             progInvokePath :: String
progInvokePath  = String
exePath,
             progInvokeArgs :: [String]
progInvokeArgs  = [String]
args,
             progInvokeEnv :: [(String, Maybe String)]
progInvokeEnv   = DistDirLayout -> ElaboratedInstallPlan -> [(String, Maybe String)]
dataDirsEnvironmentForPlan
                                 (ProjectBaseContext -> DistDirLayout
distDirLayout ProjectBaseContext
baseCtx)
                                 ElaboratedInstallPlan
elaboratedPlan
           }
  where
    ([String]
targetStr, [String]
args) = Int -> [String] -> ([String], [String])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
1 [String]
targetAndArgs

-- | Used by the main CLI parser as heuristic to decide whether @cabal@ was
-- invoked as a script interpreter, i.e. via
--
-- > #! /usr/bin/env cabal
--
-- or
--
-- > #! /usr/bin/cabal
--
-- As the first argument passed to `cabal` will be a filepath to the
-- script to be interpreted.
--
-- See also 'handleShebang'
validScript :: String -> IO Bool
validScript :: String -> IO Bool
validScript String
script
  | String -> Bool
isValid String
script Bool -> Bool -> Bool
&& (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
any Char -> Bool
isPathSeparator String
script = String -> IO Bool
doesFileExist String
script
  | Bool
otherwise = Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False

-- | Handle @cabal@ invoked as script interpreter, see also 'validScript'
--
-- First argument is the 'FilePath' to the script to be executed; second
-- argument is a list of arguments to be passed to the script.
handleShebang :: FilePath -> [String] -> IO ()
handleShebang :: String -> [String] -> IO ()
handleShebang String
script [String]
args =
  NixStyleFlags () -> [String] -> GlobalFlags -> IO ()
runAction (CommandUI (NixStyleFlags ()) -> NixStyleFlags ()
forall flags. CommandUI flags -> flags
commandDefaultFlags CommandUI (NixStyleFlags ())
runCommand) (String
scriptString -> [String] -> [String]
forall a. a -> [a] -> [a]
:[String]
args) GlobalFlags
defaultGlobalFlags

singleExeOrElse :: IO (UnitId, UnqualComponentName) -> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse :: IO (UnitId, UnqualComponentName)
-> TargetsMap -> IO (UnitId, UnqualComponentName)
singleExeOrElse IO (UnitId, UnqualComponentName)
action TargetsMap
targetsMap =
  case Set (UnitId, ComponentName) -> [(UnitId, ComponentName)]
forall a. Set a -> [a]
Set.toList (Set (UnitId, ComponentName) -> [(UnitId, ComponentName)])
-> (TargetsMap -> Set (UnitId, ComponentName))
-> TargetsMap
-> [(UnitId, ComponentName)]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetsMap -> Set (UnitId, ComponentName)
distinctTargetComponents (TargetsMap -> [(UnitId, ComponentName)])
-> TargetsMap -> [(UnitId, ComponentName)]
forall a b. (a -> b) -> a -> b
$ TargetsMap
targetsMap
  of [(UnitId
unitId, CExeName UnqualComponentName
component)] -> (UnitId, UnqualComponentName) -> IO (UnitId, UnqualComponentName)
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitId
unitId, UnqualComponentName
component)
     [(UnitId
unitId, CTestName UnqualComponentName
component)] -> (UnitId, UnqualComponentName) -> IO (UnitId, UnqualComponentName)
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitId
unitId, UnqualComponentName
component)
     [(UnitId
unitId, CBenchName UnqualComponentName
component)] -> (UnitId, UnqualComponentName) -> IO (UnitId, UnqualComponentName)
forall (m :: * -> *) a. Monad m => a -> m a
return (UnitId
unitId, UnqualComponentName
component)
     [(UnitId, ComponentName)]
_   -> IO (UnitId, UnqualComponentName)
action

-- | Filter the 'ElaboratedInstallPlan' keeping only the
-- 'ElaboratedConfiguredPackage's that match the specified
-- 'UnitId'.
matchingPackagesByUnitId :: UnitId
                         -> ElaboratedInstallPlan
                         -> [ElaboratedConfiguredPackage]
matchingPackagesByUnitId :: UnitId -> ElaboratedInstallPlan -> [ElaboratedConfiguredPackage]
matchingPackagesByUnitId UnitId
uid =
          [Maybe ElaboratedConfiguredPackage]
-> [ElaboratedConfiguredPackage]
forall a. [Maybe a] -> [a]
catMaybes
          ([Maybe ElaboratedConfiguredPackage]
 -> [ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan -> [Maybe ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (GenericPlanPackage
   InstalledPackageInfo ElaboratedConfiguredPackage
 -> Maybe ElaboratedConfiguredPackage)
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
-> [Maybe ElaboratedConfiguredPackage]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((InstalledPackageInfo -> Maybe ElaboratedConfiguredPackage)
-> (ElaboratedConfiguredPackage
    -> Maybe ElaboratedConfiguredPackage)
-> GenericPlanPackage
     InstalledPackageInfo ElaboratedConfiguredPackage
-> Maybe ElaboratedConfiguredPackage
forall ipkg a srcpkg.
(ipkg -> a) -> (srcpkg -> a) -> GenericPlanPackage ipkg srcpkg -> a
foldPlanPackage
                    (Maybe ElaboratedConfiguredPackage
-> InstalledPackageInfo -> Maybe ElaboratedConfiguredPackage
forall a b. a -> b -> a
const Maybe ElaboratedConfiguredPackage
forall a. Maybe a
Nothing)
                    (\ElaboratedConfiguredPackage
x -> if ElaboratedConfiguredPackage -> UnitId
elabUnitId ElaboratedConfiguredPackage
x UnitId -> UnitId -> Bool
forall a. Eq a => a -> a -> Bool
== UnitId
uid
                           then ElaboratedConfiguredPackage -> Maybe ElaboratedConfiguredPackage
forall a. a -> Maybe a
Just ElaboratedConfiguredPackage
x
                           else Maybe ElaboratedConfiguredPackage
forall a. Maybe a
Nothing))
          ([GenericPlanPackage
    InstalledPackageInfo ElaboratedConfiguredPackage]
 -> [Maybe ElaboratedConfiguredPackage])
-> (ElaboratedInstallPlan
    -> [GenericPlanPackage
          InstalledPackageInfo ElaboratedConfiguredPackage])
-> ElaboratedInstallPlan
-> [Maybe ElaboratedConfiguredPackage]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ElaboratedInstallPlan
-> [GenericPlanPackage
      InstalledPackageInfo ElaboratedConfiguredPackage]
forall ipkg srcpkg.
GenericInstallPlan ipkg srcpkg -> [GenericPlanPackage ipkg srcpkg]
toList

-- | This defines what a 'TargetSelector' means for the @run@ command.
-- It selects the 'AvailableTarget's that the 'TargetSelector' refers to,
-- or otherwise classifies the problem.
--
-- For the @run@ command we select the exe if there is only one and it's
-- buildable. Fail if there are no or multiple buildable exe components.
--
selectPackageTargets :: TargetSelector
                     -> [AvailableTarget k] -> Either RunTargetProblem [k]
selectPackageTargets :: TargetSelector
-> [AvailableTarget k] -> Either RunTargetProblem [k]
selectPackageTargets TargetSelector
targetSelector [AvailableTarget k]
targets

  -- If there is a single executable component, select that. See #7403
  | [k
target] <- [k]
targetsExesBuildable
  = [k] -> Either RunTargetProblem [k]
forall a b. b -> Either a b
Right [k
target]

  -- Otherwise, if there is a single executable-like component left, select that.
  | [k
target] <- [k]
targetsExeLikesBuildable
  = [k] -> Either RunTargetProblem [k]
forall a b. b -> Either a b
Right [k
target]

  -- but fail if there are multiple buildable executables.
  | Bool -> Bool
not ([k] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [k]
targetsExeLikesBuildable)
  = RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
matchesMultipleProblem TargetSelector
targetSelector [AvailableTarget ()]
targetsExeLikesBuildable')

    -- If there are executables but none are buildable then we report those
  | Bool -> Bool
not ([AvailableTarget ()] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AvailableTarget ()]
targetsExeLikes')
  = RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
forall a. TargetSelector -> [AvailableTarget ()] -> TargetProblem a
TargetProblemNoneEnabled TargetSelector
targetSelector [AvailableTarget ()]
targetsExeLikes')

    -- If there are no executables but some other targets then we report that
  | Bool -> Bool
not ([AvailableTarget k] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [AvailableTarget k]
targets)
  = RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> RunTargetProblem
noExesProblem TargetSelector
targetSelector)

    -- If there are no targets at all then we report that
  | Bool
otherwise
  = RunTargetProblem -> Either RunTargetProblem [k]
forall a b. a -> Either a b
Left (TargetSelector -> RunTargetProblem
forall a. TargetSelector -> TargetProblem a
TargetProblemNoTargets TargetSelector
targetSelector)
  where
    -- Targets that are precisely executables
    targetsExes :: [AvailableTarget k]
targetsExes = ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
ExeKind [AvailableTarget k]
targets
    targetsExesBuildable :: [k]
targetsExesBuildable = [AvailableTarget k] -> [k]
forall k. [AvailableTarget k] -> [k]
selectBuildableTargets [AvailableTarget k]
targetsExes

    -- Any target that could be executed
    targetsExeLikes :: [AvailableTarget k]
targetsExeLikes = [AvailableTarget k]
targetsExes
                   [AvailableTarget k] -> [AvailableTarget k] -> [AvailableTarget k]
forall a. [a] -> [a] -> [a]
++ ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
TestKind [AvailableTarget k]
targets
                   [AvailableTarget k] -> [AvailableTarget k] -> [AvailableTarget k]
forall a. [a] -> [a] -> [a]
++ ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
BenchKind [AvailableTarget k]
targets

    ([k]
targetsExeLikesBuildable,
     [AvailableTarget ()]
targetsExeLikesBuildable') = [AvailableTarget k] -> ([k], [AvailableTarget ()])
forall k. [AvailableTarget k] -> ([k], [AvailableTarget ()])
selectBuildableTargets' [AvailableTarget k]
targetsExeLikes

    targetsExeLikes' :: [AvailableTarget ()]
targetsExeLikes'             = [AvailableTarget k] -> [AvailableTarget ()]
forall k. [AvailableTarget k] -> [AvailableTarget ()]
forgetTargetsDetail [AvailableTarget k]
targetsExeLikes


-- | For a 'TargetComponent' 'TargetSelector', check if the component can be
-- selected.
--
-- For the @run@ command we just need to check it is a executable-like
-- (an executable, a test, or a benchmark), in addition
-- to the basic checks on being buildable etc.
--
selectComponentTarget :: SubComponentTarget
                      -> AvailableTarget k -> Either RunTargetProblem  k
selectComponentTarget :: SubComponentTarget
-> AvailableTarget k -> Either RunTargetProblem k
selectComponentTarget subtarget :: SubComponentTarget
subtarget@SubComponentTarget
WholeComponent AvailableTarget k
t
  = case AvailableTarget k -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName AvailableTarget k
t
    of CExeName UnqualComponentName
_ -> Either RunTargetProblem k
forall a. Either (TargetProblem a) k
component
       CTestName UnqualComponentName
_ -> Either RunTargetProblem k
forall a. Either (TargetProblem a) k
component
       CBenchName UnqualComponentName
_ -> Either RunTargetProblem k
forall a. Either (TargetProblem a) k
component
       ComponentName
_ -> RunTargetProblem -> Either RunTargetProblem k
forall a b. a -> Either a b
Left (PackageId -> ComponentName -> RunTargetProblem
componentNotExeProblem PackageId
pkgid ComponentName
cname)
    where pkgid :: PackageId
pkgid = AvailableTarget k -> PackageId
forall k. AvailableTarget k -> PackageId
availableTargetPackageId AvailableTarget k
t
          cname :: ComponentName
cname = AvailableTarget k -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName AvailableTarget k
t
          component :: Either (TargetProblem a) k
component = SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem a) k
forall k a.
SubComponentTarget
-> AvailableTarget k -> Either (TargetProblem a) k
selectComponentTargetBasic SubComponentTarget
subtarget AvailableTarget k
t

selectComponentTarget SubComponentTarget
subtarget AvailableTarget k
t
  = RunTargetProblem -> Either RunTargetProblem k
forall a b. a -> Either a b
Left (PackageId
-> ComponentName -> SubComponentTarget -> RunTargetProblem
isSubComponentProblem (AvailableTarget k -> PackageId
forall k. AvailableTarget k -> PackageId
availableTargetPackageId AvailableTarget k
t)
           (AvailableTarget k -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName AvailableTarget k
t)
           SubComponentTarget
subtarget)

-- | The various error conditions that can occur when matching a
-- 'TargetSelector' against 'AvailableTarget's for the @run@ command.
--
data RunProblem =
     -- | The 'TargetSelector' matches targets but no executables
     TargetProblemNoExes      TargetSelector

     -- | A single 'TargetSelector' matches multiple targets
   | TargetProblemMatchesMultiple TargetSelector [AvailableTarget ()]

     -- | Multiple 'TargetSelector's match multiple targets
   | TargetProblemMultipleTargets TargetsMap

     -- | The 'TargetSelector' refers to a component that is not an executable
   | TargetProblemComponentNotExe PackageId ComponentName

     -- | Asking to run an individual file or module is not supported
   | TargetProblemIsSubComponent  PackageId ComponentName SubComponentTarget
  deriving (RunProblem -> RunProblem -> Bool
(RunProblem -> RunProblem -> Bool)
-> (RunProblem -> RunProblem -> Bool) -> Eq RunProblem
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RunProblem -> RunProblem -> Bool
$c/= :: RunProblem -> RunProblem -> Bool
== :: RunProblem -> RunProblem -> Bool
$c== :: RunProblem -> RunProblem -> Bool
Eq, Int -> RunProblem -> String -> String
[RunProblem] -> String -> String
RunProblem -> String
(Int -> RunProblem -> String -> String)
-> (RunProblem -> String)
-> ([RunProblem] -> String -> String)
-> Show RunProblem
forall a.
(Int -> a -> String -> String)
-> (a -> String) -> ([a] -> String -> String) -> Show a
showList :: [RunProblem] -> String -> String
$cshowList :: [RunProblem] -> String -> String
show :: RunProblem -> String
$cshow :: RunProblem -> String
showsPrec :: Int -> RunProblem -> String -> String
$cshowsPrec :: Int -> RunProblem -> String -> String
Show)

type RunTargetProblem = TargetProblem RunProblem

noExesProblem :: TargetSelector -> RunTargetProblem
noExesProblem :: TargetSelector -> RunTargetProblem
noExesProblem = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem)
-> (TargetSelector -> RunProblem)
-> TargetSelector
-> RunTargetProblem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetSelector -> RunProblem
TargetProblemNoExes

matchesMultipleProblem :: TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
matchesMultipleProblem :: TargetSelector -> [AvailableTarget ()] -> RunTargetProblem
matchesMultipleProblem TargetSelector
selector [AvailableTarget ()]
targets = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem) -> RunProblem -> RunTargetProblem
forall a b. (a -> b) -> a -> b
$
    TargetSelector -> [AvailableTarget ()] -> RunProblem
TargetProblemMatchesMultiple TargetSelector
selector [AvailableTarget ()]
targets

multipleTargetsProblem :: TargetsMap -> TargetProblem RunProblem
multipleTargetsProblem :: TargetsMap -> RunTargetProblem
multipleTargetsProblem = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem)
-> (TargetsMap -> RunProblem) -> TargetsMap -> RunTargetProblem
forall b c a. (b -> c) -> (a -> b) -> a -> c
. TargetsMap -> RunProblem
TargetProblemMultipleTargets

componentNotExeProblem :: PackageId -> ComponentName -> TargetProblem RunProblem
componentNotExeProblem :: PackageId -> ComponentName -> RunTargetProblem
componentNotExeProblem PackageId
pkgid ComponentName
name = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem) -> RunProblem -> RunTargetProblem
forall a b. (a -> b) -> a -> b
$
    PackageId -> ComponentName -> RunProblem
TargetProblemComponentNotExe PackageId
pkgid ComponentName
name

isSubComponentProblem
  :: PackageId
  -> ComponentName
  -> SubComponentTarget
  -> TargetProblem RunProblem
isSubComponentProblem :: PackageId
-> ComponentName -> SubComponentTarget -> RunTargetProblem
isSubComponentProblem PackageId
pkgid ComponentName
name SubComponentTarget
subcomponent = RunProblem -> RunTargetProblem
forall a. a -> TargetProblem a
CustomTargetProblem (RunProblem -> RunTargetProblem) -> RunProblem -> RunTargetProblem
forall a b. (a -> b) -> a -> b
$
    PackageId -> ComponentName -> SubComponentTarget -> RunProblem
TargetProblemIsSubComponent PackageId
pkgid ComponentName
name SubComponentTarget
subcomponent

reportTargetProblems :: Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems :: Verbosity -> [RunTargetProblem] -> IO a
reportTargetProblems Verbosity
verbosity =
    Verbosity -> String -> IO a
forall a. Verbosity -> String -> IO a
die' Verbosity
verbosity (String -> IO a)
-> ([RunTargetProblem] -> String) -> [RunTargetProblem] -> IO a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
unlines ([String] -> String)
-> ([RunTargetProblem] -> [String]) -> [RunTargetProblem] -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (RunTargetProblem -> String) -> [RunTargetProblem] -> [String]
forall a b. (a -> b) -> [a] -> [b]
map RunTargetProblem -> String
renderRunTargetProblem

renderRunTargetProblem :: RunTargetProblem -> String
renderRunTargetProblem :: RunTargetProblem -> String
renderRunTargetProblem (TargetProblemNoTargets TargetSelector
targetSelector) =
    case TargetSelector -> Maybe ComponentKind
targetSelectorFilter TargetSelector
targetSelector of
      Just ComponentKind
kind | ComponentKind
kind ComponentKind -> ComponentKind -> Bool
forall a. Eq a => a -> a -> Bool
/= ComponentKind
ExeKind
        -> String
"The run command is for running executables, but the target '"
           String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
           String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."

      Maybe ComponentKind
_ -> String -> TargetSelector -> String
renderTargetProblemNoTargets String
"run" TargetSelector
targetSelector
renderRunTargetProblem RunTargetProblem
problem =
    String -> (RunProblem -> String) -> RunTargetProblem -> String
forall a. String -> (a -> String) -> TargetProblem a -> String
renderTargetProblem String
"run" RunProblem -> String
renderRunProblem RunTargetProblem
problem

renderRunProblem :: RunProblem -> String
renderRunProblem :: RunProblem -> String
renderRunProblem (TargetProblemMatchesMultiple TargetSelector
targetSelector [AvailableTarget ()]
targets) =
    String
"The run command is for running a single executable at once. The target '"
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" which includes "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
renderListCommaAnd ( (String
"the "String -> String -> String
forall a. [a] -> [a] -> [a]
++) (String -> String)
-> (ComponentName -> String) -> ComponentName -> String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         ComponentName -> String
showComponentName (ComponentName -> String)
-> (AvailableTarget () -> ComponentName)
-> AvailableTarget ()
-> String
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         AvailableTarget () -> ComponentName
forall k. AvailableTarget k -> ComponentName
availableTargetComponentName (AvailableTarget () -> String) -> [AvailableTarget ()] -> [String]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
                         (ComponentKind -> [AvailableTarget ()])
-> [ComponentKind] -> [AvailableTarget ()]
forall (t :: * -> *) m a.
(Foldable t, Monoid m) =>
(a -> m) -> t a -> m
foldMap
                           (\ComponentKind
kind -> ComponentKind -> [AvailableTarget ()] -> [AvailableTarget ()]
forall k.
ComponentKind -> [AvailableTarget k] -> [AvailableTarget k]
filterTargetsKind ComponentKind
kind [AvailableTarget ()]
targets)
                           [ComponentKind
ExeKind, ComponentKind
TestKind, ComponentKind
BenchKind] )
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."

renderRunProblem (TargetProblemMultipleTargets TargetsMap
selectorMap) =
    String
"The run command is for running a single executable at once. The targets "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ [String] -> String
renderListCommaAnd [ String
"'" String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
ts String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"'"
                       | TargetSelector
ts <- TargetsMap -> [TargetSelector]
uniqueTargetSelectors TargetsMap
selectorMap ]
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" refer to different executables."

renderRunProblem (TargetProblemComponentNotExe PackageId
pkgid ComponentName
cname) =
    String
"The run command is for running executables, but the target '"
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" from the package "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ PackageId -> String
forall a. Pretty a => a -> String
prettyShow PackageId
pkgid String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."
  where
    targetSelector :: TargetSelector
targetSelector = PackageId -> ComponentName -> SubComponentTarget -> TargetSelector
TargetComponent PackageId
pkgid ComponentName
cname SubComponentTarget
WholeComponent

renderRunProblem (TargetProblemIsSubComponent PackageId
pkgid ComponentName
cname SubComponentTarget
subtarget) =
    String
"The run command can only run an executable as a whole, "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"not files or modules within them, but the target '"
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' refers to "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"."
  where
    targetSelector :: TargetSelector
targetSelector = PackageId -> ComponentName -> SubComponentTarget -> TargetSelector
TargetComponent PackageId
pkgid ComponentName
cname SubComponentTarget
subtarget

renderRunProblem (TargetProblemNoExes TargetSelector
targetSelector) =
    String
"Cannot run the target '" String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
showTargetSelector TargetSelector
targetSelector
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
"' which refers to " String -> String -> String
forall a. [a] -> [a] -> [a]
++ TargetSelector -> String
renderTargetSelector TargetSelector
targetSelector
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" because "
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ Plural -> String -> String -> String
forall a. Plural -> a -> a -> a
plural (TargetSelector -> Plural
targetSelectorPluralPkgs TargetSelector
targetSelector) String
"it does" String
"they do"
 String -> String -> String
forall a. [a] -> [a] -> [a]
++ String
" not contain any executables."