:: MonadLogger m

=> FilePath -> [JSONWarning] -> m ()

logJSONWarnings fp =

-- | Handle warnings in a sub-object.

jsonSubWarnings :: WarningParser (WithJSONWarnings a) -> WarningParser a

-> m ()

storeEncodeFile pokeFunc peekFunc fp x = do

let fpt = T.pack (toFilePath fp)

ensureDir (parent fp)

let (sz, poker) = pokeFunc x

encoded = unsafeEncodeWith poker sz

assert (decodeExWith peekFunc encoded == x) $ liftIO $ BS.writeFile (toFilePath fp) encoded

-- | Read from the given file. If the read fails, run the given action and

-> m a

versionedDecodeOrLoadImpl pokeFunc peekFunc fp mx = do

let fpt = T.pack (toFilePath fp)

mres <- versionedDecodeFileImpl peekFunc fp

case mres of

Just x -> do

return x

_ -> do

x <- mx

storeEncodeFile pokeFunc peekFunc fp x

return x

-> m (Maybe a)

versionedDecodeFileImpl peekFunc fp = do

mbs <- liftIO (Just <$> BS.readFile (toFilePath fp)) `catch` \(err :: IOException) -> do

return Nothing

case mbs of

Nothing -> return Nothing

Just bs ->

liftIO (Just <$> decodeIOWith peekFunc bs) `catch` \(err :: PeekException) -> do

let fpt = T.pack (toFilePath fp)

return Nothing

storeVersionConfig :: String -> String -> VersionConfig a

-> Path Abs File -- ^ destination

-> m Bool

redownload req0 dest = do

let destFilePath = toFilePath dest

etagFilePath = destFilePath <.> "etag"

verifiedDownload DownloadRequest{..} destpath progressSink = do

let req = drRequest

whenM' (liftIO getShouldDownload) $ do

liftIO $ do

createDirectoryIfMissing True dir

recoveringHttp drRetryPolicy $

Just exePath -> do

exeDir <- (liftIO . fmap FP.takeDirectory . D.canonicalizePath) exePath

unless (exeDir `FP.equalFilePath` destDir) $ do

[ "WARNING: The \""

, exe

, "\" executable found on the PATH environment variable is "

, T.pack exePath

, ", and not the version that was just installed."

]

[ "This means that \""

, exe

, "\" calls on the command line will not use this version."

]

Nothing -> do

[ "WARNING: Installation path "

, T.pack destDir

, " is on the PATH but the \""

, exe

, "\" executable that was just installed could not be found on the PATH."

]

else do

[ "WARNING: Installation path "

, T.pack destDir

, " not found on the PATH environment variable"

-- NOTE: This policy is too conservative. In the future we should be able to

-- schedule unlocking as an Action that happens after all non-local actions are

-- complete.

liftIO $ unlockFile lk

_ -> return ()

warnIfExecutablesWithSameNameCouldBeOverwritten

:: MonadLogger m => [LocalPackage] -> Plan -> m ()

warnIfExecutablesWithSameNameCouldBeOverwritten locals plan = do

forM_ (Map.toList warnings) $ \(exe,(toBuild,otherLocals)) -> do

let exe_s

| length toBuild > 1 = "several executables with the same name:"

T.intercalate

", "

["'" <> packageNameText p <> ":" <> exe <> "'" | p <- pkgs]

[ [ "Building " <> exe_s <> " " <> exesText toBuild <> "." ]

, [ "Only one of them will be available via 'stack exec' or locally installed."

| length toBuild > 1

warnAboutSplitObjs :: MonadLogger m => BuildOpts -> m ()

warnAboutSplitObjs bopts | boptsSplitObjs bopts = do

warnAboutSplitObjs _ = return ()

splitObjsWarning :: String

fixInput $ fixOutput inner

expected = 65001 -- UTF-8

[ "Setting"

, typ

, " codepage to UTF-8 (65001) to ensure correct output from GHC"

-> Bool

-> RIO env Plan

constructPlan ls0 baseConfigOpts0 locals extraToBuild0 localDumpPkgs loadPackage0 sourceMap installedMap initialBuildSteps = do

u <- askUnliftIO

econfig <- view envConfigL

lp <- getLocalPackages

((), m, W efinals installExes dirtyReason deps warnings parents) <-

liftIO $ runRWST inner (ctx econfig (unliftIO u . getPackageVersions) lp) M.empty

let toEither (_, Left e) = Left e

toEither (k, Right v) = Right (k, v)

(errlibs, adrs) = partitionEithers $ map toEither $ M.toList m