case builder of

                 Ar Pack stg -> do

                     useTempFile <- arSupportsAtFile stg

                                    else runArWithoutTempFile path buildArgs buildInputs buildOptions

                 Ar Unpack _ -> cmd' [Cwd output] [path] buildArgs buildOptions

                     Exit _ <- cmd' [path] (buildArgs ++ [input]) buildOptions

                     return ()

                 Ghc _ _ ->

                   -- Use a response file for ghc invocations to avoid issues with command line

                   -- empty arguments (such as the -dep-suffix flag), but that isn't supported

                   -- yet due to #26560.

                   withResponseFileIfLongCmd

                     (toCmdArgument [path] <> toCmdArgument buildArgs)

                     buildInputs

                     (toCmdArgument buildOptions)

 -- | Invoke @haddock@ given a path to it and a list of arguments. On Windows,

 -- the input file arguments are passed as a response file.

       -> [String]

       -> [FilePath]  -- ^ input file paths

       -> Action ()

   (toCmdArgument [haddockPath] <> toCmdArgument flagArgs)

   fileInputs

   (CmdArgument [])

     lookupBignum,

     cmdBignum, cmdProgressInfo, cmdCompleteSetting,

     cmdDocsArgs, cmdUnitIdHash, lookupBuildRoot, TestArgs(..), TestSpeed(..), defaultTestArgs,

     ) where

 import Data.Either

 import Data.List.Extra

 import Development.Shake hiding (Normal)

 import Flavour (DocTargets, DocTarget(..))

 import Settings.Parser

 import System.Console.GetOpt

 import System.Environment

     , testArgs       :: TestArgs

     , docsArgs       :: DocArgs

     , docTargets     :: DocTargets

     , prefix           :: Maybe FilePath

     , changelogVersion :: Maybe String

     , completeStg      :: Maybe String }

     , testArgs       = defaultTestArgs

     , docsArgs       = defaultDocArgs

     , docTargets     = Set.fromList [minBound..maxBound]

     , prefix           = Nothing

     , changelogVersion = Nothing

     , completeStg      = Nothing }

 readFreeze2 = Right $ \flags -> flags { freeze1 = True, freeze2 = True }

 readSkipDepends = Right $ \flags -> flags { skipDepends = True }

 readUnitIdHash :: Either String (CommandLineArgs -> CommandLineArgs)

 readUnitIdHash = Right $ \flags ->

   trace "--hash-unit-ids is deprecated. It is enabled by release flavour or +hash_unit_ids flavour transformer" $

       "Progress info style (None, Brief, Normal or Unicorn)."

     , Option [] ["docs"] (ReqArg readDocsArg "TARGET")

       "Strip down docs targets (none, no-haddocks, no-sphinx[-{html, pdfs, man}]."

     , Option ['k'] ["keep-test-files"] (NoArg readTestKeepFiles)

       "Keep all the files generated when running the testsuite."

     , Option [] ["test-compiler"] (ReqArg readTestCompiler "TEST_COMPILER")

     return $ insertExtra (progressInfo               args) -- Accessed by Hadrian.Utilities

            $ insertExtra (buildRoot                  args) -- Accessed by Hadrian.Utilities

            $ insertExtra (testArgs                   args) -- Accessed by Settings.Builders.RunTest

            $ insertExtra (docsArgs                   args) -- Accessed by Rules.Documentation

            $ insertExtra allSettings                       -- Accessed by Settings

 cmdBignum :: Action (Maybe String)

 cmdBignum = bignum <$> cmdLineArgs

 cmdProgressInfo :: Action ProgressInfo

 cmdProgressInfo = progressInfo <$> cmdLineArgs

 import Development.Shake.Classes

 import GHC.Generics

 import Hadrian.Utilities

 -- | We support packing and unpacking archives with @ar@.

 data ArMode = Pack | Unpack deriving (Eq, Generic, Show)

 -- to be archived is passed via a temporary response file. Passing arguments

 -- via a response file is not supported by some versions of @ar@, in which

 -- case you should use 'runArWithoutTempFile' instead.

       -> [String]    -- ^ other arguments

       -> [FilePath]  -- ^ input file paths

       -> [CmdOption] -- ^ Additional options

       -> Action ()

 -- | Invoke @ar@ given a path to it and a list of arguments. Note that @ar@

 -- will be called multiple times if the list of files to be archived is too

     -- * Paths

     BuildRoot (..), buildRoot, buildRootRules, isGeneratedSource,

     -- * File system operations

     copyFile, copyFileUntracked, createFileLink, fixFile,

 import Development.Shake.FilePath

 import GHC.ResponseFile (escapeArgs)

 import System.Environment (lookupEnv)

 import System.IO.Error (isPermissionError)

 import qualified Data.ByteString        as BS

 isGeneratedSource :: FilePath -> Action Bool

 isGeneratedSource file = buildRoot <&> (`isPrefixOf` file)

 -- | Run an command with the given arguments. If the command is too long then the

 -- response file arguments are placed into a response file and escaped with @GHC.ResponseFile.escapeArgs@.

 --

 -- With @--keep-response-files@, the file is left on disk (if used)

 withResponseFileIfLongCmd :: (CmdResult c) =>

     -> [String]     -- ^ Response file aruguments.

     -> CmdArgument  -- ^ Command arguments after the response file arguments.

     -> Action c

     let cmdLineLengh = sum

             [ 1 + length arg -- add one to account for space inbetween arguments

             | let CmdArgument args = argsPre <> toCmdArgument argsResp <> argsPost

             , Right arg <- args

             ]

 -- | Link a file tracking the link target. Create the target directory if

 -- missing.