Replacing cabal-helper-0.8.1.2 with 1.1.0.0

12 files changed, 0 insertions, 2395 deletions

diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/Environment.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/Environment.hs
deleted file mode 100644
index 58bb9ee..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/Environment.hs
+++ /dev/null
@@ -1,35 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2017  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE CPP #-}
-module CabalHelper.Compiletime.Compat.Environment where
-
-import qualified System.Environment
-#ifndef mingw32_HOST_OS
-import qualified System.Posix.Env (setEnv)
-#endif
-
-lookupEnv :: String -> IO (Maybe String)
-lookupEnv var =
-  do env <- System.Environment.getEnvironment
-     return (lookup var env)
-
-setEnv :: String -> String -> IO ()
-#ifdef mingw32_HOST_OS
-setEnv = System.Environment.setEnv
-#else
-setEnv k v = System.Posix.Env.setEnv k v True
-#endif
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/ProgramDb.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/ProgramDb.hs
deleted file mode 100644
index 56b033c..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/ProgramDb.hs
+++ /dev/null
@@ -1,30 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE CPP #-}
-module CabalHelper.Compiletime.Compat.ProgramDb
-    ( defaultProgramDb
-    , programPath
-    , lookupProgram
-    , ghcProgram
-    , ghcPkgProgram
-    ) where
-
-import Distribution.Simple.Program
-
-#if !MIN_VERSION_Cabal(2,0,0)
-defaultProgramDb = defaultProgramConfiguration
-#endif
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/Version.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/Version.hs
deleted file mode 100644
index 5d4f5f5..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compat/Version.hs
+++ /dev/null
@@ -1,49 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2017-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE CPP #-}
-module CabalHelper.Compiletime.Compat.Version
-    ( DataVersion
-    , toDataVersion
-    , fromDataVersion
-    , Data.Version.showVersion
-    , makeDataVersion
-    ) where
-
-import qualified Data.Version
-import qualified Distribution.Version (Version)
-#if MIN_VERSION_Cabal(2,0,0)
-import qualified Distribution.Version  (versionNumbers, mkVersion)
-#endif
-
-type DataVersion = Data.Version.Version
-
-toDataVersion :: Distribution.Version.Version -> Data.Version.Version
-fromDataVersion :: Data.Version.Version -> Distribution.Version.Version
-#if MIN_VERSION_Cabal(2,0,0)
-toDataVersion v = Data.Version.Version (Distribution.Version.versionNumbers v) []
-fromDataVersion (Data.Version.Version vs _) = Distribution.Version.mkVersion vs
-#else
-toDataVersion = id
-fromDataVersion = id
-#endif
-
-makeDataVersion :: [Int] -> Data.Version.Version
-#if MIN_VERSION_base(4,8,0)
-makeDataVersion = Data.Version.makeVersion
-#else
-makeDataVersion xs = Data.Version.Version xs []
-#endif
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compile.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compile.hs
deleted file mode 100644
index 8da426f..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Compile.hs
+++ /dev/null
@@ -1,736 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-{-# LANGUAGE RecordWildCards, FlexibleContexts, NamedFieldPuns, DeriveFunctor,
-GADTs #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Compile
-Description : Runtime compilation machinery
-License     : GPL-3
--}
-
-module CabalHelper.Compiletime.Compile where
-
-import Cabal.Plan
-import Control.Applicative
-import Control.Arrow
-import Control.Exception as E
-import Control.Monad
-import Control.Monad.Trans.Maybe
-import Control.Monad.IO.Class
-import Data.Char
-import Data.List
-import Data.Maybe
-import Data.String
-import Data.Version
-import GHC.IO.Exception (IOErrorType(OtherError))
-import Text.Printf
-import Text.Read
-import System.Directory
-import System.FilePath
-import System.Process
-import System.Exit
-import System.Environment
-import System.IO
-import System.IO.Error
-import System.IO.Temp
-import Prelude
-
-
-import qualified Data.Text as Text
-import qualified Data.Map.Strict as Map
-
-import Distribution.System (buildPlatform)
-import Distribution.Text (display)
-
-import Paths_cabal_helper (version)
-import CabalHelper.Compiletime.Data
-import CabalHelper.Compiletime.Log
-import CabalHelper.Compiletime.Types
-import CabalHelper.Shared.Common
-import CabalHelper.Shared.Sandbox (getSandboxPkgDb)
-
-data Compile
-    = CompileWithCabalSource
-      { compCabalSourceDir     :: CabalSourceDir
-      , compCabalSourceVersion :: Version
-      }
-    | CompileWithCabalPackage
-      { compPackageDb      :: Maybe PackageDbDir
-      , compCabalVersion   :: CabalVersion
-      , compPackageDeps    :: [String]
-      , compProductTarget  :: CompilationProductScope
-      }
-
-data CompPaths = CompPaths
-    { compSrcDir  :: FilePath
-    , compOutDir  :: FilePath
-    , compExePath :: FilePath
-    }
-
--- | The Helper executable we produce as a compilation product can either be
--- placed in a per-project location, or a per-user/global location in the user's
--- home directory. This type controls where the compilation process places the
--- executable.
-data CompilationProductScope = CPSGlobal | CPSProject
-
-compileHelper :: Options -> Version -> FilePath -> Maybe (PlanJson, FilePath) -> FilePath -> IO (Either ExitCode FilePath)
-compileHelper opts hdrCabalVersion projdir mnewstyle distdir = do
-  ghcVer <- ghcVersion opts
-  Just (prepare, comp) <- runMaybeT $ msum $
-    case oCabalPkgDb opts of
-      Nothing ->
-        [ compileCabalSource
-        , compileNewBuild ghcVer
-        , compileSandbox ghcVer
-        , compileGlobal
-        , MaybeT $ Just <$> compileWithCabalInPrivatePkgDb
-        ]
-      Just db ->
-          [ return $ (return (), compileWithPkg (Just db) hdrCabalVersion CPSProject)
-        ]
-
-  appdir <- appCacheDir
-
-  let cp@CompPaths {compExePath} = compPaths appdir distdir comp
-  exists <- doesFileExist compExePath
-  if exists
-    then do
-      vLog opts $ "helper already compiled, using exe: "++compExePath
-      return (Right compExePath)
-    else do
-      vLog opts $ "helper exe does not exist, compiling "++compExePath
-      prepare >> compile comp cp opts
-
- where
-   logMsg = "using helper compiled with Cabal from "
-
--- for relaxed deps: find (sameMajorVersionAs hdrCabalVersion) . reverse . sort
-
-   -- | Check if this version is globally available
-   compileGlobal :: MaybeT IO (IO (), Compile)
-   compileGlobal = do
-       cabal_versions <- listCabalVersions opts
-       ver <- MaybeT $ return $ find (== hdrCabalVersion) cabal_versions
-       vLog opts $ logMsg ++ "user/global package-db"
-       return $ (return (), compileWithPkg Nothing ver CPSGlobal)
-
-   -- | Check if this version is available in the project sandbox
-   compileSandbox :: Version -> MaybeT IO (IO (), Compile)
-   compileSandbox ghcVer = do
-       let mdb_path = getSandboxPkgDb projdir (display buildPlatform) ghcVer
-       sandbox <- PackageDbDir <$> MaybeT mdb_path
-       cabal_versions <- listCabalVersions' opts (Just sandbox)
-       ver <- MaybeT $ return $ find (== hdrCabalVersion) cabal_versions
-       vLog opts $ logMsg ++ "sandbox package-db"
-       return $ (return (), compileWithPkg (Just sandbox) ver CPSProject)
-
-   compileNewBuild :: Version -> MaybeT IO (IO (), Compile)
-   compileNewBuild ghcVer = do
-       (PlanJson {pjUnits}, distdir_newstyle) <- maybe mzero pure mnewstyle
-       let cabal_pkgid =
-               PkgId (PkgName (Text.pack "Cabal"))
-                     (Ver $ versionBranch hdrCabalVersion)
-           mcabal_unit = listToMaybe $
-             Map.elems $ Map.filter (\Unit {..} -> uPId == cabal_pkgid) pjUnits
-       Unit {} <- maybe mzero pure mcabal_unit
-       let inplace_db_path = distdir_newstyle
-             </> "packagedb" </> ("ghc-" ++ showVersion ghcVer)
-           inplace_db = PackageDbDir inplace_db_path
-       cabal_versions <- listCabalVersions' opts (Just inplace_db)
-       ver <- MaybeT $ return $ find (== hdrCabalVersion) cabal_versions
-       vLog opts $ logMsg ++ "v2-build package-db " ++ inplace_db_path
-       return $ (return (), compileWithPkg (Just inplace_db) ver CPSProject)
-
-   -- | Compile the requested Cabal version into an isolated package-db if it's
-   -- not there already
-   compileWithCabalInPrivatePkgDb :: IO (IO (), Compile)
-   compileWithCabalInPrivatePkgDb = do
-       db@(PackageDbDir db_path)
-           <- getPrivateCabalPkgDb opts (CabalVersion hdrCabalVersion)
-       vLog opts $ logMsg ++ "private package-db in " ++ db_path
-       return (prepare db, compileWithPkg (Just db) hdrCabalVersion CPSGlobal)
-     where
-       prepare db = do
-         db_exists <- liftIO $ cabalVersionExistsInPkgDb opts hdrCabalVersion db
-         when (not db_exists) $
-           void $ installCabal opts (Right hdrCabalVersion) `E.catch`
-             \(SomeException _) -> errorInstallCabal hdrCabalVersion distdir
-
-   -- | See if we're in a cabal source tree
-   compileCabalSource :: MaybeT IO (IO (), Compile)
-   compileCabalSource = do
-       let cabalFile = projdir </> "Cabal.cabal"
-       cabalSrc <- liftIO $ doesFileExist cabalFile
-       let projdir' = CabalSourceDir projdir
-       case cabalSrc of
-         False -> mzero
-         True -> do
-           vLog opts $ "projdir looks like Cabal source tree (Cabal.cabal exists)"
-           cf <- liftIO $ readFile cabalFile
-           let buildType = cabalFileBuildType cf
-               ver       = cabalFileVersion cf
-
-           case buildType of
-             "simple" -> do
-                 vLog opts $ "Cabal source tree is build-type:simple, moving on"
-                 mzero
-             "custom" -> do
-                 vLog opts $ "compiling helper with local Cabal source tree"
-                 return $ (return (), compileWithCabalSource projdir' ver)
-             _ -> error $ "compileCabalSource: unknown build-type: '"++buildType++"'"
-
-   compileWithCabalSource srcDir ver =
-       CompileWithCabalSource
-          { compCabalSourceDir       = srcDir
-          , compCabalSourceVersion   = ver
-          }
-
-   compileWithPkg mdb ver target =
-       CompileWithCabalPackage
-          { compPackageDb            = mdb
-          , compCabalVersion         = CabalVersion ver
-          , compPackageDeps          = [cabalPkgId ver]
-          , compProductTarget        = target
-          }
-
-   cabalPkgId v = "Cabal-" ++ showVersion v
-
-compile :: Compile -> CompPaths -> Options -> IO (Either ExitCode FilePath)
-compile comp paths@CompPaths {..} opts@Options {..} = do
-    createDirectoryIfMissing True compOutDir
-    createHelperSources compSrcDir
-
-    vLog opts $ "compSrcDir: " ++ compSrcDir
-    vLog opts $ "compOutDir: " ++ compOutDir
-    vLog opts $ "compExePath: " ++ compExePath
-
-    invokeGhc opts $ compGhcInvocation comp paths
-
-compPaths :: FilePath -> FilePath -> Compile -> CompPaths
-compPaths appdir distdir c =
-    case c of
-      CompileWithCabalPackage {compProductTarget=CPSGlobal,..} -> CompPaths {..}
-        where
-          compSrcDir  = appdir </> exeName compCabalVersion <.> "build"
-          compOutDir  = compSrcDir
-          compExePath = appdir </> exeName compCabalVersion
-
-      CompileWithCabalPackage {compProductTarget=CPSProject,..} -> distdirPaths
-      CompileWithCabalSource {..} -> distdirPaths
-  where
-    distdirPaths = CompPaths {..}
-        where
-          compSrcDir  = distdir </> "cabal-helper"
-          compOutDir  = compSrcDir
-          compExePath = compOutDir </> "cabal-helper"
-
-data GhcInvocation = GhcInvocation
-    { giOutDir          :: FilePath
-    , giOutput          :: FilePath
-    , giCPPOptions      :: [String]
-    , giPackageDBs      :: [PackageDbDir]
-    , giIncludeDirs     :: [FilePath]
-    , giHideAllPackages :: Bool
-    , giPackages        :: [String]
-    , giWarningFlags    :: [String]
-    , giInputs          :: [String]
-    }
-
-compGhcInvocation :: Compile -> CompPaths -> GhcInvocation
-compGhcInvocation comp CompPaths {..} =
-    case comp of
-      CompileWithCabalSource {..} ->
-        GhcInvocation
-          { giIncludeDirs = [compSrcDir, unCabalSourceDir compCabalSourceDir]
-          , giPackageDBs  = []
-          , giHideAllPackages = False
-          , giPackages    = []
-          , giCPPOptions = cppOptions compCabalSourceVersion
-                           ++ [cabalVersionMacro compCabalSourceVersion]
-          , ..
-          }
-      CompileWithCabalPackage {..} ->
-        GhcInvocation
-          { giIncludeDirs = [compSrcDir]
-          , giPackageDBs = maybeToList compPackageDb
-          , giHideAllPackages = True
-          , giPackages =
-              [ "base"
-              , "containers"
-              , "directory"
-              , "filepath"
-              , "process"
-              , "bytestring"
-              , "ghc-prim"
-              ] ++ compPackageDeps
-          , giCPPOptions = cppOptions (unCabalVersion compCabalVersion)
-          , ..
-          }
-  where
-
-    unCabalVersion (CabalVersion ver) = ver
-    unCabalVersion (CabalHEAD _)      = Version [10000000, 0, 0] []
-
-    cppOptions cabalVer =
-        [ "-DCABAL_HELPER=1"
-        , cabalMinVersionMacro cabalVer
-        ]
-
-    giOutDir = compOutDir
-    giOutput = compExePath
-    giWarningFlags = [ "-w" ] -- no point in bothering end users with warnings
-    giInputs = [compSrcDir</>"CabalHelper"</>"Runtime"</>"Main.hs"]
-
-cabalVersionMacro :: Version -> String
-cabalVersionMacro (Version vs _) =
-  "-DCABAL_VERSION="++intercalate "," (map show vs)
-
-cabalMinVersionMacro :: Version -> String
-cabalMinVersionMacro (Version (mj1:mj2:mi:_) _) =
-  "-DCH_MIN_VERSION_Cabal(major1,major2,minor)=\
-  \(  (major1)  < "++show mj1++" \
-  \|| (major1) == "++show mj1++" && (major2)  < "++show mj2++" \
-  \|| (major1) == "++show mj1++" && (major2) == "++show mj2++" && (minor) <= "++show mi++
-  ")"
-cabalMinVersionMacro _ =
-    error "cabalMinVersionMacro: Version must have at least 3 components"
-
-invokeGhc :: Options -> GhcInvocation -> IO (Either ExitCode FilePath)
-invokeGhc opts@Options {..} GhcInvocation {..} = do
-  rv <- callProcessStderr' opts Nothing oGhcProgram $ concat
-    [ [ "-outputdir", giOutDir
-      , "-o", giOutput
-      ]
-    , map ("-optP"++) giCPPOptions
-    , map ("-package-conf="++) $ unPackageDbDir <$> giPackageDBs
-    , map ("-i"++) $ nub $ "" : giIncludeDirs
-    , if giHideAllPackages then ["-hide-all-packages"] else []
-    , concatMap (\p -> ["-package", p]) giPackages
-    , giWarningFlags
-    , ["--make"]
-    , giInputs
-    ]
-  return $
-    case rv of
-      ExitSuccess -> Right giOutput
-      e@(ExitFailure _) -> Left e
-
-
--- | Cabal library version we're compiling the helper exe against.
-data CabalVersion
-    = CabalHEAD  { cvCommitId   :: CommitId }
-    | CabalVersion { cabalVersion :: Version }
-
-newtype CommitId = CommitId { unCommitId :: String }
-
-exeName :: CabalVersion -> String
-exeName (CabalHEAD commitid) = intercalate "-"
-    [ "cabal-helper" ++ showVersion version
-    , "CabalHEAD" ++ unCommitId commitid
-    ]
-exeName CabalVersion {cabalVersion} = intercalate "-"
-    [ "cabal-helper" ++ showVersion version
-    , "Cabal" ++ showVersion cabalVersion
-    ]
-
-readProcess' :: Options -> FilePath -> [String] -> String -> IO String
-readProcess' opts@Options{..} exe args inp = do
-  vLog opts $ intercalate " " $ map formatProcessArg (oGhcPkgProgram:args)
-  outp <- readProcess exe args inp
-  vLog opts $ unlines $ map ("=> "++) $ lines outp
-  return outp
-
-callProcessStderr'
-    :: Options -> Maybe FilePath -> FilePath -> [String] -> IO ExitCode
-callProcessStderr' opts mwd exe args = do
-  let cd = case mwd of
-             Nothing -> []; Just wd -> [ "cd", formatProcessArg wd++";" ]
-  vLog opts $ intercalate " " $ cd ++ map formatProcessArg (exe:args)
-  (_, _, _, h) <- createProcess (proc exe args) { std_out = UseHandle stderr
-                                                , cwd = mwd }
-  waitForProcess h
-
-callProcessStderr :: Options -> Maybe FilePath -> FilePath -> [String] -> IO ()
-callProcessStderr opts mwd exe args = do
-  rv <- callProcessStderr' opts mwd exe args
-  case rv of
-    ExitSuccess -> return ()
-    ExitFailure v -> processFailedException "callProcessStderr" exe args v
-
-processFailedException :: String -> String -> [String] -> Int -> IO a
-processFailedException fn exe args rv =
-    ioError $ mkIOError OtherError msg Nothing Nothing
-  where
-    msg = concat [ fn, ": ", exe, " "
-                 , intercalate " " (map formatProcessArg args)
-                 , " (exit " ++ show rv ++ ")"
-                 ]
-
-formatProcessArg :: String -> String
-formatProcessArg xs
-    | any isSpace xs = "'"++ xs ++"'"
-    | otherwise      = xs
-
-data HEAD = HEAD deriving (Eq, Show)
-
-installCabal :: Options -> Either HEAD Version -> IO (PackageDbDir, CabalVersion)
-installCabal opts ever = do
-  appdir <- appCacheDir
-  let message ver = do
-      let sver = showVersion ver
-      hPutStr stderr $ printf "\
-\cabal-helper-wrapper: Installing a private copy of Cabal because we couldn't\n\
-\find the right version in your global/user package-db, this might take a\n\
-\while but will only happen once per Cabal version you're using.\n\
-\\n\
-\If anything goes horribly wrong just delete this directory and try again:\n\
-\    %s\n\
-\\n\
-\If you want to avoid this automatic installation altogether install\n\
-\version %s of Cabal manually (into your user or global package-db):\n\
-\    $ cabal install Cabal --constraint \"Cabal == %s\"\n\
-\\n\
-\Installing Cabal %s ...\n" appdir sver sver sver
-
-  withSystemTempDirectory "cabal-helper-Cabal-source" $ \tmpdir -> do
-    (srcdir, cabalVer) <- case ever of
-      Left HEAD -> do
-        second CabalHEAD <$> unpackCabalHEAD opts tmpdir
-      Right ver -> do
-        message ver
-        let patch = fromMaybe nopCabalPatchDescription $
-              find ((ver`elem`) . cpdVersions) patchyCabalVersions
-        (,) <$> unpackPatchedCabal opts ver tmpdir patch <*> pure (CabalVersion ver)
-
-    db <- createPkgDb opts cabalVer
-
-    runCabalInstall opts db srcdir ever
-
-    return (db, cabalVer)
-
-{-
-TODO: If the Cabal version we want to install is less than or equal to one we
-have available, either through act-as-setup or in a package-db we should be able
-to use act-as-setup or build a default Setup.hs exe and patch the Cabal source
-to say build-type:simple. This will sidestep bugs in c-i>=1.24
-
-See conversation in
-https://github.com/haskell/cabal/commit/e2bf243300957321497353a2f85517e464f764ab
-
-Otherwise we might be able to use the shipped Setup.hs
-
--}
-
-runCabalInstall
-    :: Options -> PackageDbDir -> CabalSourceDir -> Either HEAD Version-> IO ()
-runCabalInstall opts (PackageDbDir db) (CabalSourceDir srcdir) ever = do
-  civ@CabalInstallVersion {..} <- cabalInstallVersion opts
-  cabal_opts <- return $ concat
-      [
-        [ "--package-db=clear"
-        , "--package-db=global"
-        , "--package-db=" ++ db
-        , "--prefix=" ++ db </> "prefix"
-        ]
-        , withGHCProgramOptions opts
-        , if cabalInstallVer >= Version [1,20,0,0] []
-             then ["--no-require-sandbox"]
-             else []
-        , [ "install", srcdir ]
-        , if oVerbose opts
-            then ["-v"]
-            else []
-        , [ "--only-dependencies" ]
-      ]
-
-  callProcessStderr opts (Just "/") (oCabalProgram opts) cabal_opts
-
-  runSetupHs opts db srcdir ever civ
-
-  hPutStrLn stderr "done"
-
-withGHCProgramOptions :: Options -> [String]
-withGHCProgramOptions opts =
-    concat [ [ "--with-ghc=" ++ oGhcProgram opts ]
-           , if oGhcPkgProgram opts /= oGhcPkgProgram defaultOptions
-               then [ "--with-ghc-pkg=" ++ oGhcPkgProgram opts ]
-               else []
-           ]
-
-runSetupHs
-    :: Options
-    -> FilePath
-    -> FilePath
-    -> Either HEAD Version
-    -> CabalInstallVersion
-    -> IO ()
-runSetupHs opts@Options {..} db srcdir ever CabalInstallVersion {..}
-    | cabalInstallVer >= parseVer "1.24" = do
-      go $ \args -> callProcessStderr opts (Just srcdir) oCabalProgram $
-        [ "act-as-setup", "--" ] ++ args
-    | otherwise = do
-      SetupProgram {..} <- compileSetupHs opts db srcdir
-      go $ callProcessStderr opts (Just srcdir) setupProgram
-  where
-    parmake_opt :: Maybe Int -> [String]
-    parmake_opt nproc'
-        | Left _ <- ever = ["-j"++nproc]
-        | Right ver <- ever,  ver >= Version [1,20] [] = ["-j"++nproc]
-        | otherwise = []
-      where
-        nproc = fromMaybe "" $ show <$> nproc'
-
-    go :: ([String] -> IO ()) -> IO ()
-    go run = do
-      run $ [ "configure", "--package-db", db, "--prefix", db </> "prefix" ]
-              ++ withGHCProgramOptions opts
-      mnproc <- join . fmap readMaybe <$> lookupEnv "NPROC"
-      run $ [ "build" ] ++ parmake_opt mnproc
-      run [ "copy" ]
-      run [ "register" ]
-
-
-
-
-newtype SetupProgram = SetupProgram { setupProgram :: FilePath }
-compileSetupHs :: Options -> FilePath -> FilePath -> IO SetupProgram
-compileSetupHs opts db srcdir = do
-  ver <- ghcVersion opts
-  let no_version_macros
-        | ver >= Version [8] [] = [ "-fno-version-macros" ]
-        | otherwise             = []
-
-      file = srcdir </> "Setup"
-
-  callProcessStderr opts (Just srcdir) (oGhcProgram opts) $ concat
-    [ [ "--make"
-      , "-package-conf", db
-      ]
-    , no_version_macros
-    , [ file <.> "hs"
-      , "-o", file
-      ]
-    ]
-  return $ SetupProgram file
-
-data CabalPatchDescription = CabalPatchDescription {
-      cpdVersions      :: [Version],
-      cpdUnpackVariant :: UnpackCabalVariant,
-      cpdPatchFn       :: FilePath -> IO ()
-    }
-nopCabalPatchDescription :: CabalPatchDescription
-nopCabalPatchDescription = CabalPatchDescription [] LatestRevision (const (return ()))
-
-patchyCabalVersions :: [CabalPatchDescription]
-patchyCabalVersions = [
-  let versions  = [ Version [1,18,1] [] ]
-      variant   = Pristine
-      patch     = fixArrayConstraint
-  in CabalPatchDescription versions variant patch,
-
-  let versions  = [ Version [1,18,0] [] ]
-      variant   = Pristine
-      patch dir = do
-        fixArrayConstraint dir
-        fixOrphanInstance dir
-  in CabalPatchDescription versions variant patch,
-
-  let versions  = [ Version [1,24,1,0] [] ]
-      variant   = Pristine
-      patch _   = return ()
-  in CabalPatchDescription versions variant patch
-  ]
- where
-   fixArrayConstraint dir = do
-     let cabalFile    = dir </> "Cabal.cabal"
-         cabalFileTmp = cabalFile ++ ".tmp"
-
-     cf <- readFile cabalFile
-     writeFile cabalFileTmp $ replace "&& < 0.5" "&& < 0.6" cf
-     renameFile cabalFileTmp cabalFile
-
-   fixOrphanInstance dir = do
-     let versionFile    = dir </> "Distribution/Version.hs"
-         versionFileTmp = versionFile ++ ".tmp"
-
-     let languagePragma =
-           "{-# LANGUAGE DeriveDataTypeable, StandaloneDeriving #-}"
-         languagePragmaCPP =
-           "{-# LANGUAGE CPP, DeriveDataTypeable, StandaloneDeriving #-}"
-
-         derivingDataVersion =
-           "deriving instance Data Version"
-         derivingDataVersionCPP = unlines [
-             "#if __GLASGOW_HASKELL__ < 707",
-             derivingDataVersion,
-             "#endif"
-           ]
-
-     vf <- readFile versionFile
-     writeFile versionFileTmp
-       $ replace derivingDataVersion derivingDataVersionCPP
-       $ replace languagePragma languagePragmaCPP vf
-
-     renameFile versionFileTmp versionFile
-
-unpackPatchedCabal
-    :: Options
-    -> Version
-    -> FilePath
-    -> CabalPatchDescription
-    -> IO CabalSourceDir
-unpackPatchedCabal opts cabalVer tmpdir (CabalPatchDescription _ variant patch) = do
-  res@(CabalSourceDir dir) <- unpackCabal opts cabalVer tmpdir variant
-  patch dir
-  return res
-
-data UnpackCabalVariant = Pristine | LatestRevision
-newtype CabalSourceDir = CabalSourceDir { unCabalSourceDir :: FilePath }
-unpackCabal
-    :: Options -> Version -> FilePath -> UnpackCabalVariant -> IO CabalSourceDir
-unpackCabal opts cabalVer tmpdir variant = do
-  let cabal = "Cabal-" ++ showVersion cabalVer
-      dir = tmpdir </> cabal
-      variant_opts = case variant of Pristine -> [ "--pristine" ]; _ -> []
-      args = [ "get", cabal ] ++ variant_opts
-  callProcessStderr opts (Just tmpdir) (oCabalProgram opts) args
-  return $ CabalSourceDir dir
-
-unpackCabalHEAD :: Options -> FilePath -> IO (CabalSourceDir, CommitId)
-unpackCabalHEAD opts tmpdir = do
-  let dir = tmpdir </> "cabal-head.git"
-      url = "https://github.com/haskell/cabal.git"
-  ExitSuccess <- rawSystem "git" [ "clone", "--depth=1", url, dir]
-  commit <-
-      withDirectory_ dir $ trim <$> readProcess' opts "git" ["rev-parse", "HEAD"] ""
-  return (CabalSourceDir $ dir </> "Cabal", CommitId commit)
- where
-   withDirectory_ :: FilePath -> IO a -> IO a
-   withDirectory_ dir action =
-       bracket
-         (liftIO getCurrentDirectory)
-         (liftIO . setCurrentDirectory)
-         (\_ -> liftIO (setCurrentDirectory dir) >> action)
-
-errorInstallCabal :: Version -> FilePath -> IO a
-errorInstallCabal cabalVer _distdir = panicIO $ printf "\
-\Installing Cabal version %s failed.\n\
-\\n\
-\You have the following choices to fix this:\n\
-\\n\
-\- The easiest way to try and fix this is just reconfigure the project and try\n\
-\  again:\n\
-\        $ cabal clean && cabal configure\n\
-\\n\
-\- If that fails you can try to install the version of Cabal mentioned above\n\
-\  into your global/user package-db somehow, you'll probably have to fix\n\
-\  something otherwise it wouldn't have failed above:\n\
-\        $ cabal install Cabal --constraint 'Cabal == %s'\n\
-\\n\
-\- If you're using `Build-Type: Simple`:\n\
-\  - You can see if you can reinstall your cabal-install executable while\n\
-\    having it linked to a version of Cabal that's available in you\n\
-\    package-dbs or can be built automatically:\n\
-\        $ ghc-pkg list | grep Cabal  # find an available Cabal version\n\
-\            Cabal-W.X.Y.Z\n\
-\        $ cabal install cabal-install --constraint 'Cabal == W.X.*'\n\
-\    Afterwards you'll have to reconfigure your project:\n\
-\        $ cabal clean && cabal configure\n\
-\\n\
-\- If you're using `Build-Type: Custom`:\n\
-\  - Have cabal-install rebuild your Setup.hs executable with a version of the\n\
-\    Cabal library that you have available in your global/user package-db:\n\
-\        $ cabal clean && cabal configure\n\
-\    You might also have to install some version of the Cabal to do this:\n\
-\        $ cabal install Cabal\n\
-\\n" sver sver
- where
-   sver = showVersion cabalVer
-
-listCabalVersions :: Options -> MaybeT IO [Version]
-listCabalVersions opts = listCabalVersions' opts Nothing
-
-listCabalVersions' :: Options -> Maybe PackageDbDir -> MaybeT IO [Version]
-listCabalVersions' opts@Options {..} mdb = do
-  case mdb of
-    Nothing -> mzero
-    Just (PackageDbDir db_path) -> do
-      exists <- liftIO $ doesDirectoryExist db_path
-      case exists of
-        False -> mzero
-        True  -> MaybeT $ logIOError opts "listCabalVersions'" $ Just <$> do
-          let mdbopt = ("--package-conf="++) <$> unPackageDbDir <$> mdb
-              args = ["list", "--simple-output", "Cabal"] ++ maybeToList mdbopt
-
-          catMaybes . map (fmap snd . parsePkgId . fromString) . words
-                   <$> readProcess' opts oGhcPkgProgram args ""
-
-cabalVersionExistsInPkgDb :: Options -> Version -> PackageDbDir -> IO Bool
-cabalVersionExistsInPkgDb opts cabalVer db@(PackageDbDir db_path) = do
-  exists <- doesDirectoryExist db_path
-  case exists of
-    False -> return False
-    True -> fromMaybe False <$> runMaybeT (do
-      vers <- listCabalVersions' opts (Just db)
-      return $ cabalVer `elem` vers)
-
-ghcVersion :: Options -> IO Version
-ghcVersion opts@Options {..} = do
-    parseVer . trim <$> readProcess' opts oGhcProgram ["--numeric-version"] ""
-
-ghcPkgVersion :: Options -> IO Version
-ghcPkgVersion opts@Options {..} = do
-    parseVer . trim . dropWhile (not . isDigit) <$> readProcess' opts oGhcPkgProgram ["--version"] ""
-
-newtype CabalInstallVersion = CabalInstallVersion { cabalInstallVer :: Version }
-cabalInstallVersion :: Options -> IO CabalInstallVersion
-cabalInstallVersion opts@Options {..} = do
-    CabalInstallVersion . parseVer . trim
-      <$> readProcess' opts oCabalProgram ["--numeric-version"] ""
-
-createPkgDb :: Options -> CabalVersion -> IO PackageDbDir
-createPkgDb opts@Options {..} cabalVer = do
-  db@(PackageDbDir db_path) <- getPrivateCabalPkgDb opts cabalVer
-  exists <- doesDirectoryExist db_path
-  when (not exists) $ callProcessStderr opts Nothing oGhcPkgProgram ["init", db_path]
-  return db
-
-getPrivateCabalPkgDb :: Options -> CabalVersion -> IO PackageDbDir
-getPrivateCabalPkgDb opts cabalVer = do
-  appdir <- appCacheDir
-  ghcVer <- ghcVersion opts
-  let db_path = appdir </> exeName cabalVer
-                ++ "-ghc" ++ showVersion ghcVer
-                ++ ".package-db"
-  return $ PackageDbDir db_path
-
--- "Cabal" ++ ver ++ "-ghc" ++ showVersion ghcVer
-
--- | Find @version: XXX@ delcaration in a cabal file
-cabalFileVersion :: String -> Version
-cabalFileVersion = parseVer . cabalFileTopField "version"
-
--- | Find @build-type: XXX@ delcaration in a cabal file
-cabalFileBuildType :: String -> String
-cabalFileBuildType = cabalFileTopField "build-type"
-
-cabalFileTopField :: String -> String -> String
-cabalFileTopField field cabalFile = value
- where
-  Just value = extract <$> find ((field++":") `isPrefixOf`) ls
-  ls = map (map toLower) $ lines cabalFile
-  extract = dropWhile (/=':') >>> drop 1 >>> dropWhile isSpace >>> takeWhile (not . isSpace)
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Data.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Data.hs
deleted file mode 100644
index 80df962..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Data.hs
+++ /dev/null
@@ -1,81 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2017  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE TemplateHaskell, ScopedTypeVariables #-}
-{-# OPTIONS_GHC -fforce-recomp #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Data
-Description : Embeds source code for runtime component using TH
-License     : GPL-3
--}
-
-module CabalHelper.Compiletime.Data where
-
-import Control.Monad
-import Control.Monad.IO.Class
-import Data.Functor
-import qualified Data.ByteString as BS
-import qualified Data.ByteString.UTF8 as UTF8
-import Language.Haskell.TH
-import System.Directory
-import System.FilePath
-import System.IO.Temp
-import System.PosixCompat.Files
-import System.PosixCompat.Time
-import System.PosixCompat.Types
-import Prelude
-
-import CabalHelper.Compiletime.Compat.Environment
-
-withSystemTempDirectoryEnv :: String -> (FilePath -> IO b) -> IO b
-withSystemTempDirectoryEnv tpl f = do
-  m <- liftIO $ lookupEnv "CABAL_HELPER_KEEP_SOURCEDIR"
-  case m of
-    Nothing -> withSystemTempDirectory tpl f
-    Just _  -> do
-           tmpdir <- getCanonicalTemporaryDirectory
-           f =<< createTempDirectory tmpdir tpl
-
-createHelperSources :: FilePath -> IO ()
-createHelperSources dir = do
-    let chdir = dir </> "CabalHelper"
-    liftIO $ do
-      createDirectoryIfMissing True $ chdir </> "Runtime"
-      createDirectoryIfMissing True $ chdir </> "Shared"
-
-    let modtime :: EpochTime
-        modtime = fromIntegral $ (read :: String -> Integer)
-          -- See https://reproducible-builds.org/specs/source-date-epoch/
-          $(runIO $ do
-             msde :: Maybe Integer
-                  <- fmap read <$> lookupEnv "SOURCE_DATE_EPOCH"
-             (current_time :: Integer) <- round . toRational <$> epochTime
-             return $ LitE . StringL $ show $ maybe current_time id msde)
-
-    liftIO $ forM_ sourceFiles $ \(fn, src) -> do
-        let path = chdir </> fn
-        BS.writeFile path $ UTF8.fromString src
-        setFileTimes path modtime modtime
-
-
-sourceFiles :: [(FilePath, String)]
-sourceFiles =
-  [ ("Runtime/Main.hs",     $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "src/CabalHelper/Runtime/Main.hs")))
-  , ("Shared/Common.hs",    $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "src/CabalHelper/Shared/Common.hs")))
-  , ("Shared/Sandbox.hs",   $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "src/CabalHelper/Shared/Sandbox.hs")))
-  , ("Shared/InterfaceTypes.hs",     $(LitE . StringL <$> runIO (UTF8.toString <$> BS.readFile "src/CabalHelper/Shared/InterfaceTypes.hs")))
-  ]
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Log.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Log.hs
deleted file mode 100644
index a329c54..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Log.hs
+++ /dev/null
@@ -1,45 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2017-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE ScopedTypeVariables #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Log
-Description : Basic logging facilities
-License     : GPL-3
--}
-
-module CabalHelper.Compiletime.Log where
-
-import Control.Monad
-import Control.Monad.IO.Class
-import Control.Exception as E
-import Data.String
-import System.IO
-import Prelude
-
-import CabalHelper.Compiletime.Types
-
-vLog :: MonadIO m => Options -> String -> m ()
-vLog Options { oVerbose = True } msg =
-    liftIO $ hPutStrLn stderr msg
-vLog _ _ = return ()
-
-logIOError :: Options -> String -> IO (Maybe a) -> IO (Maybe a)
-logIOError opts label a = do
-  a `E.catch` \(ex :: IOError) -> do
-      vLog opts $ label ++ ": " ++ show ex
-      return Nothing
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Types.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Types.hs
deleted file mode 100644
index 77c3255..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Types.hs
+++ /dev/null
@@ -1,42 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE DeriveGeneric, DeriveDataTypeable, DefaultSignatures #-}
-
-{-|
-Module      : CabalHelper.Compiletime.Types
-Description : Types used throughout
-License     : GPL-3
--}
-
-module CabalHelper.Compiletime.Types where
-
-import Data.Version
-
-data Options = Options {
-          oHelp          :: Bool
-        , oVerbose       :: Bool
-        , oGhcProgram    :: FilePath
-        , oGhcPkgProgram :: FilePath
-        , oCabalProgram  :: FilePath
-        , oCabalVersion  :: Maybe Version
-        , oCabalPkgDb    :: Maybe PackageDbDir
-}
-
-newtype PackageDbDir = PackageDbDir { unPackageDbDir :: FilePath }
-
-defaultOptions :: Options
-defaultOptions = Options False False "ghc" "ghc-pkg" "cabal" Nothing Nothing
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Wrapper.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Wrapper.hs
deleted file mode 100644
index 461ef96..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Compiletime/Wrapper.hs
+++ /dev/null
@@ -1,227 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-{-# LANGUAGE RecordWildCards, NamedFieldPuns, FlexibleContexts, ViewPatterns #-}
-module Main where
-
-import Cabal.Plan
-import Control.Applicative
-import Control.Monad
-import Data.Char
-import Data.List
-import Data.Maybe
-import Data.String
-import Text.Printf
-import Text.Show.Pretty
-import System.Console.GetOpt
-import System.Environment
-import System.Directory
-import System.FilePath
-import System.Process
-import System.Exit
-import System.IO
-import Prelude
-
-import qualified Data.Text as Text
-import qualified Data.Map.Strict as Map
-
-import Distribution.System (buildPlatform)
-import Distribution.Text (display)
-import Distribution.Verbosity (silent, deafening)
-import Distribution.Package (packageName, packageVersion)
-import Distribution.Simple.GHC as GHC (configure)
-
-import Paths_cabal_helper (version)
-import CabalHelper.Compiletime.Compat.ProgramDb
-    ( defaultProgramDb, programPath, lookupProgram, ghcProgram, ghcPkgProgram)
-import CabalHelper.Compiletime.Compat.Version
-import CabalHelper.Compiletime.Compile
-import CabalHelper.Compiletime.Types
-import CabalHelper.Shared.Common
-import CabalHelper.Shared.InterfaceTypes
-
-usage :: IO ()
-usage = do
-  prog <- getProgName
-  hPutStr stderr $ "Usage: " ++ prog ++ " " ++ usageMsg
- where
-   usageMsg = "\
-\( print-appcachedir\n\
-\| print-build-platform\n\
-\| [--verbose]\n\
-\  [--with-ghc=GHC_PATH]\n\
-\  [--with-ghc-pkg=GHC_PKG_PATH]\n\
-\  [--with-cabal=CABAL_PATH]\n\
-\  [--with-cabal-version=VERSION]\n\
-\  [--with-cabal-pkg-db=PKG_DB]\n\
-\  v1-style PROJ_DIR DIST_DIR \n\
-\      ( print-exe | package-id | [CABAL_HELPER_ARGS...] )\n\
-\  v2-style PROJ_DIR DIST_NEWSTYLE_DIR DIST_DIR\n\
-\      ( print-exe | package-id | [CABAL_HELPER_ARGS...] )\n\
-\)\n"
-
-globalArgSpec :: [OptDescr (Options -> Options)]
-globalArgSpec =
-      [ option "h" ["help"] "Display help message" $
-              NoArg $ \o -> o { oHelp = True }
-      , option "" ["verbose"] "Be more verbose" $
-              NoArg $ \o -> o { oVerbose = True }
-
-      , option "" ["with-ghc"] "GHC executable to use" $
-              reqArg "PROG" $ \p o -> o { oGhcProgram = p }
-
-      , option "" ["with-ghc-pkg"] "ghc-pkg executable to use (only needed when guessing from GHC path fails)" $
-              reqArg "PROG" $ \p o -> o { oGhcPkgProgram = p }
-
-      , option "" ["with-cabal"] "cabal-install executable to use" $
-               reqArg "PROG" $ \p o -> o { oCabalProgram = p }
-
-      , option "" ["with-cabal-version"] "Cabal library version to use" $
-               reqArg "VERSION" $ \p o -> o { oCabalVersion = Just $ parseVer p }
-
-      , option "" ["with-cabal-pkg-db"] "package database to look for Cabal library in" $
-               reqArg "PKG_DB" $ \p o -> o { oCabalPkgDb = Just (PackageDbDir p) }
-
-      ]
- where
-   option :: [Char] -> [String] -> String -> ArgDescr a -> OptDescr a
-   option s l udsc dsc = Option s l dsc udsc
-
-   reqArg :: String -> (String -> a) -> ArgDescr a
-   reqArg udsc dsc = ReqArg dsc udsc
-
-parseCommandArgs :: Options -> [String] -> (Options, [String])
-parseCommandArgs opts argv
-    = case getOpt RequireOrder globalArgSpec argv of
-        (o,r,[])   -> (foldr id opts o, r)
-        (_,_,errs) ->
-            panic $ "Parsing command options failed:\n" ++ concat errs
-
-guessProgramPaths :: Options -> IO Options
-guessProgramPaths opts = do
-    let v | oVerbose opts = deafening
-          | otherwise     = silent
-
-        mGhcPath0    | same oGhcProgram opts dopts = Nothing
-                     | otherwise = Just $ oGhcProgram opts
-        mGhcPkgPath0 | same oGhcPkgProgram opts dopts = Nothing
-                     | otherwise = Just $ oGhcPkgProgram opts
-
-    (_compiler, _mplatform, progdb)
-        <- GHC.configure
-               v
-               mGhcPath0
-               mGhcPkgPath0
-               defaultProgramDb
-
-    let mghcPath1    = programPath <$> lookupProgram ghcProgram progdb
-        mghcPkgPath1 = programPath <$> lookupProgram ghcPkgProgram progdb
-
-    return $ opts { oGhcProgram    = fromMaybe (oGhcProgram opts) mghcPath1
-                  , oGhcPkgProgram = fromMaybe (oGhcProgram opts) mghcPkgPath1
-                  }
- where
-   same f o o'  = f o == f o'
-   dopts = defaultOptions
-
-overrideVerbosityEnvVar :: Options -> IO Options
-overrideVerbosityEnvVar opts = do
-  x <- lookup  "CABAL_HELPER_DEBUG" <$> getEnvironment
-  return $ case x of
-    Just _  -> opts { oVerbose = True }
-    Nothing -> opts
-
-main :: IO ()
-main = handlePanic $ do
-  (opts', args) <- parseCommandArgs defaultOptions <$> getArgs
-  opts <- overrideVerbosityEnvVar =<< guessProgramPaths opts'
-  case args of
-    _ | oHelp opts -> usage
-    [] -> usage
-    "help":[] -> usage
-    "version":[] -> putStrLn $ showVersion version
-    "print-appdatadir":[] -> putStrLn =<< appCacheDir
-    "print-appcachedir":[] -> putStrLn =<< appCacheDir
-    "print-build-platform":[] -> putStrLn $ display buildPlatform
-
-    _:projdir:_distdir:"package-id":[] -> do
-      let v | oVerbose opts = deafening
-            | otherwise    = silent
-      -- ghc-mod will catch multiple cabal files existing before we get here
-      [cfile] <- filter isCabalFile <$> getDirectoryContents projdir
-      gpd <- readPackageDescription v (projdir </> cfile)
-      putStrLn $ show $
-        [Just $ ChResponseVersion (display (packageName gpd)) (toDataVersion $ packageVersion gpd)]
-
-    "v2-style":projdir:distdir_newstyle:unitid':args' -> do
-      let unitid = UnitId $ Text.pack unitid'
-      let plan_path = distdir_newstyle </> "cache" </> "plan.json"
-      plan@PlanJson {pjCabalLibVersion=Ver (makeDataVersion -> pjCabalLibVersion) }
-          <- decodePlanJson plan_path
-      case oCabalVersion opts of
-        Just ver | pjCabalLibVersion /= ver -> let
-            sver = showVersion ver
-            spjVer = showVersion pjCabalLibVersion
-          in panic $ printf "\
-\Cabal version %s was requested but plan.json was written by version %s" sver spjVer
-        _ -> case Map.lookup unitid $ pjUnits plan of
-               Just u@Unit {uType} | uType /= UnitTypeLocal -> do
-                 panic $ "\
-\UnitId '"++ unitid' ++"' points to non-local unit: " ++ ppShow u
-               Just Unit {uDistDir=Nothing} -> panic $ printf "\
-\plan.json doesn't contain 'dist-dir' for UnitId '"++ unitid' ++"'"
-               Just Unit {uType=UnitTypeLocal, uDistDir=Just distdir} ->
-                 runHelper opts projdir (Just (plan, distdir_newstyle)) distdir pjCabalLibVersion args'
-               _ -> let
-                   units = map (\(UnitId u) -> Text.unpack u)
-                         $ Map.keys
-                         $ Map.filter ((==UnitTypeLocal) . uType)
-                         $ pjUnits plan
-
-                   units_list = unlines $ map ("  "++) units
-                 in
-                   panic $ "\
-\UnitId '"++ unitid' ++"' not found in plan.json, available local units:\n" ++ units_list
-
-    "v1-style":projdir:distdir:args' -> do
-      cfgf <- canonicalizePath (distdir </> "setup-config")
-      mhdr <- getCabalConfigHeader cfgf
-      case (mhdr, oCabalVersion opts) of
-        (Nothing, _) -> panic $ printf "\
-\Could not read Cabal's persistent setup configuration header\n\
-\- Check first line of: %s\n\
-\- Maybe try: $ cabal configure" cfgf
-        (Just (hdrCabalVersion, _), Just ver)
-          | hdrCabalVersion /= ver -> panic $ printf "\
-\Cabal version %s was requested but setup configuration was\n\
-\written by version %s" (showVersion ver) (showVersion hdrCabalVersion)
-        (Just (hdrCabalVersion, _), _) ->
-          runHelper opts projdir Nothing distdir hdrCabalVersion args'
-    _ -> do
-      hPutStrLn stderr "Invalid command line!"
-      usage
-      exitWith $ ExitFailure 1
-
-runHelper :: Options -> FilePath -> Maybe (PlanJson, FilePath) -> FilePath -> DataVersion -> [String] -> IO ()
-runHelper opts projdir mnewstyle distdir cabal_ver args' = do
-  eexe <- compileHelper opts cabal_ver projdir mnewstyle distdir
-  case eexe of
-      Left e -> exitWith e
-      Right exe -> do
-        case args' of
-          "print-exe":_ -> putStrLn exe
-          _ -> do
-            (_,_,_,h) <- createProcess $ proc exe $ projdir : distdir : args'
-            exitWith =<< waitForProcess h
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Runtime/Main.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Runtime/Main.hs
deleted file mode 100644
index 78260f8..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Runtime/Main.hs
+++ /dev/null
@@ -1,841 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE CPP, BangPatterns, RecordWildCards, RankNTypes, ViewPatterns #-}
-
-#ifdef MIN_VERSION_Cabal
-#undef CH_MIN_VERSION_Cabal
-#define CH_MIN_VERSION_Cabal MIN_VERSION_Cabal
-#endif
-
-import Distribution.Simple.Utils (cabalVersion)
-import Distribution.Simple.Configure
-import Distribution.Package
-  ( PackageIdentifier
-  , InstalledPackageId
-  , PackageId
-  , packageName
-  , packageVersion
-  )
-import Distribution.PackageDescription
-  ( PackageDescription
-  , GenericPackageDescription(..)
-  , Flag(..)
-  , FlagName(..)
-  , FlagAssignment
-  , Executable(..)
-  , Library(..)
-  , TestSuite(..)
-  , Benchmark(..)
-  , BuildInfo(..)
-  , TestSuiteInterface(..)
-  , BenchmarkInterface(..)
-  , withLib
-  )
-import Distribution.PackageDescription.Configuration
-  ( flattenPackageDescription
-  )
-import Distribution.Simple.Program
-  ( requireProgram
-  , ghcProgram
-  )
-import Distribution.Simple.Program.Types
-  ( ConfiguredProgram(..)
-  )
-import Distribution.Simple.Configure
-  ( getPersistBuildConfig
-  )
-import Distribution.Simple.LocalBuildInfo
-  ( LocalBuildInfo(..)
-  , Component(..)
-  , ComponentName(..)
-  , ComponentLocalBuildInfo(..)
-  , componentBuildInfo
-  , externalPackageDeps
-  , withComponentsLBI
-  , withLibLBI
-  , withExeLBI
-  )
-import Distribution.Simple.GHC
-  ( componentGhcOptions
-  )
-import Distribution.Simple.Program.GHC
-  ( GhcOptions(..)
-  , renderGhcOptions
-  )
-import Distribution.Simple.Setup
-  ( ConfigFlags(..)
-  , Flag(..)
-  , fromFlagOrDefault
-  )
-import Distribution.Simple.Build
-  ( initialBuildSteps
-  )
-import Distribution.Simple.BuildPaths
-  ( autogenModuleName
-  , cppHeaderName
-  )
-import Distribution.Simple.Compiler
-  ( PackageDB(..)
-  , compilerId
-  )
-import Distribution.Compiler
-  ( CompilerId(..)
-  )
-import Distribution.ModuleName
-  ( components
-  )
-import qualified Distribution.ModuleName as C
-  ( ModuleName
-  )
-import Distribution.Text
-  ( display
-  )
-import Distribution.Verbosity
-  ( Verbosity
-  , silent
-  , deafening
-  , normal
-  )
-import Distribution.Version
-  ( Version
-  )
-
-#if CH_MIN_VERSION_Cabal(1,22,0)
--- CPP >= 1.22
-import Distribution.Utils.NubList
-#endif
-
-#if CH_MIN_VERSION_Cabal(1,23,0)
--- >= 1.23
-import Distribution.Simple.LocalBuildInfo
-  ( localUnitId
-  )
-#else
--- <= 1.22
-import Distribution.Simple.LocalBuildInfo
-  ( inplacePackageId
-  )
-#endif
-
-#if CH_MIN_VERSION_Cabal(1,25,0)
--- >=1.25
-import Distribution.PackageDescription
-  ( unFlagName
-  -- , mkFlagName
-  )
-import Distribution.Types.ForeignLib
-  ( ForeignLib(..)
-  )
-import Distribution.Types.UnqualComponentName
-  ( unUnqualComponentName
-  )
-#endif
-
-#if CH_MIN_VERSION_Cabal(2,0,0)
--- CPP >= 2.0
-import Distribution.Simple.LocalBuildInfo
-  ( allLibModules
-  , componentBuildDir
-  )
-import Distribution.Simple.Register
-  ( internalPackageDBPath
-  )
-import Distribution.Backpack
-  ( OpenUnitId(..),
-    OpenModule(..)
-  )
-import Distribution.ModuleName
-  ( ModuleName
-  )
-import Distribution.Types.ComponentId
-  ( unComponentId
-  )
-import Distribution.Types.ComponentLocalBuildInfo
-  ( maybeComponentInstantiatedWith
-  )
-import Distribution.Types.ModuleRenaming
-  ( ModuleRenaming(..),
-    isDefaultRenaming
-  )
-import Distribution.Types.MungedPackageId
-  ( MungedPackageId
-  )
-import Distribution.Types.UnitId
-  ( UnitId
-  , unDefUnitId
-  , unUnitId
-  )
-import Distribution.Types.UnitId
-  ( DefUnitId
-  )
-import Distribution.Utils.NubList
-  ( toNubListR
-  )
-import Distribution.Version
-  ( versionNumbers
-  , mkVersion
-  )
-import qualified Distribution.InstalledPackageInfo as Installed
-#endif
-
-#if CH_MIN_VERSION_Cabal(2,2,0)
-import Distribution.Types.GenericPackageDescription
-  ( unFlagAssignment
-  )
-#endif
-
-import Control.Applicative ((<$>))
-import Control.Arrow (first, second, (&&&))
-import Control.Monad
-import Control.Exception (catch, PatternMatchFail(..))
-import Data.List
-import qualified Data.Map as Map
-import Data.Maybe
-import Data.Monoid
-import Data.IORef
-import qualified Data.Version as DataVersion
-import System.Environment
-import System.Directory
-import System.FilePath
-import System.Exit
-import System.IO
-import System.IO.Unsafe (unsafeInterleaveIO, unsafePerformIO)
-import Text.Printf
-
-import CabalHelper.Shared.Sandbox
-import CabalHelper.Shared.Common
-import CabalHelper.Shared.InterfaceTypes
-
-usage :: IO ()
-usage = do
-  prog <- getProgName
-  hPutStr stderr $ "Usage: " ++ prog ++ " " ++ usageMsg
- where
-   usageMsg = ""
-     ++"PROJ_DIR DIST_DIR [--with-* ...] (\n"
-     ++"    version\n"
-     ++"  | print-lbi [--human]\n"
-     ++"  | package-id\n"
-     ++"  | flags\n"
-     ++"  | config-flags\n"
-     ++"  | non-default-config-flags\n"
-     ++"  | write-autogen-files\n"
-     ++"  | compiler-version\n"
-     ++"  | ghc-options     [--with-inplace]\n"
-     ++"  | ghc-src-options [--with-inplace]\n"
-     ++"  | ghc-pkg-options [--with-inplace]\n"
-     ++"  | ghc-merged-pkg-options [--with-inplace]\n"
-     ++"  | ghc-lang-options [--with-inplace]\n"
-     ++"  | package-db-stack\n"
-     ++"  | entrypoints\n"
-     ++"  | needs-build-output\n"
-     ++"  | source-dirs\n"
-     ++"  ) ...\n"
-
-commands :: [String]
-commands = [ "print-lbi"
-           , "package-id"
-           , "flags"
-           , "config-flags"
-           , "non-default-config-flags"
-           , "write-autogen-files"
-           , "compiler-version"
-           , "ghc-options"
-           , "ghc-src-options"
-           , "ghc-pkg-options"
-           , "ghc-lang-options"
-           , "package-db-stack"
-           , "entrypoints"
-           , "needs-build-output"
-           , "source-dirs"
-           ]
-
-main :: IO ()
-main = do
-  args <- getArgs
-
-  projdir:distdir:args' <- case args of
-                    [] -> usage >> exitFailure
-                    _ -> return args
-
-  ddexists <- doesDirectoryExist distdir
-  when (not ddexists) $ do
-         errMsg $ "distdir '"++distdir++"' does not exist"
-         exitFailure
-
-  [cfile] <- filter isCabalFile <$> getDirectoryContents projdir
-
-  v <- maybe silent (const deafening) . lookup  "CABAL_HELPER_DEBUG" <$> getEnvironment
-  lbi <- unsafeInterleaveIO $ getPersistBuildConfig distdir
-  gpd <- unsafeInterleaveIO $ readPackageDescription v (projdir </> cfile)
-  let pd = localPkgDescr lbi
-  let lvd = (lbi, v, distdir)
-
-  let
-      -- a =<< b $$ c   ==  (a =<< b) $$ c
-      infixr 2 $$
-      ($$) = ($)
-
-      collectCmdOptions :: [String] -> [[String]]
-      collectCmdOptions =
-          reverse . map reverse . foldl f [] . dropWhile isOpt
-       where
-         isOpt = ("--" `isPrefixOf`)
-         f [] x = [[x]]
-         f (a:as) x
-             | isOpt x = (x:a):as
-             | otherwise = [x]:(a:as)
-
-  let cmds = collectCmdOptions args'
-
-  if any (["version"] `isPrefixOf`) cmds
-    then do
-      putStrLn $
-       printf "using version %s of the Cabal library" (display cabalVersion)
-      exitSuccess
-    else return ()
-
-  print =<< flip mapM cmds $$ \x -> do
-  case x of
-    "flags":[] -> do
-      return $ Just $ ChResponseFlags $ sort $
-        map (flagName' &&& flagDefault) $ genPackageFlags gpd
-
-    "config-flags":[] -> do
-      return $ Just $ ChResponseFlags $ sort $
-        map (first unFlagName)
-#if CH_MIN_VERSION_Cabal(2,2,0)
-          $ unFlagAssignment $ configConfigurationsFlags
-#else
-          $ configConfigurationsFlags
-#endif
-          $ configFlags lbi
-
-    "non-default-config-flags":[] -> do
-      let flagDefinitons = genPackageFlags gpd
-          flagAssgnments =
-#if CH_MIN_VERSION_Cabal(2,2,0)
-            unFlagAssignment $ configConfigurationsFlags
-#else
-            configConfigurationsFlags
-#endif
-              $ configFlags lbi
-          nonDefaultFlags =
-              [ (flag_name, val)
-              | MkFlag {flagName=(unFlagName -> flag_name'), flagDefault=def_val} <- flagDefinitons
-              , (unFlagName -> flag_name, val) <- flagAssgnments
-              , flag_name == flag_name'
-              , val /= def_val
-              ]
-      return $ Just $ ChResponseFlags $ sort nonDefaultFlags
-
-    "write-autogen-files":[] -> do
-      initialBuildStepsForAllComponents distdir pd lbi v
-      return Nothing
-
-    "compiler-version":[] -> do
-      let CompilerId comp ver = compilerId $ compiler lbi
-      return $ Just $ ChResponseVersion (show comp) (toDataVersion ver)
-
-    "ghc-options":flags -> do
-      res <- componentOptions lvd True flags id
-      return $ Just $ ChResponseCompList (res ++ [(ChSetupHsName, [])])
-
-    "ghc-src-options":flags -> do
-      res <- componentOptions lvd False flags $ \opts -> mempty {
-               -- Not really needed but "unexpected package db stack: []"
-               ghcOptPackageDBs      = [GlobalPackageDB, UserPackageDB],
-
-               ghcOptCppOptions      = ghcOptCppOptions opts,
-               ghcOptCppIncludePath  = ghcOptCppIncludePath opts,
-               ghcOptCppIncludes     = ghcOptCppIncludes opts,
-               ghcOptFfiIncludes     = ghcOptFfiIncludes opts,
-               ghcOptSourcePathClear = ghcOptSourcePathClear opts,
-               ghcOptSourcePath      = ghcOptSourcePath opts
-              }
-      return $ Just $ ChResponseCompList (res ++ [(ChSetupHsName, [])])
-
-    "ghc-pkg-options":flags -> do
-      res <- componentOptions lvd True flags $ \opts -> mempty {
-                       ghcOptPackageDBs = ghcOptPackageDBs opts,
-                       ghcOptPackages   = ghcOptPackages opts,
-                       ghcOptHideAllPackages = ghcOptHideAllPackages opts
-                   }
-      return $ Just $ ChResponseCompList (res ++ [(ChSetupHsName, [])])
-
-    "ghc-merged-pkg-options":flags -> do
-      res <- mconcat . map snd <$> (componentOptions' lvd True flags (\_ _ o -> return o) $ \opts -> mempty {
-                       ghcOptPackageDBs = [],
-                       ghcOptHideAllPackages = NoFlag,
-                       ghcOptPackages   = ghcOptPackages opts
-                   })
-
-      let res' = nubPackageFlags $ res { ghcOptPackageDBs = withPackageDB lbi
-                                       , ghcOptHideAllPackages = Flag True
-                                       }
-
-      Just . ChResponseList <$> renderGhcOptions' lbi v res'
-
-    "ghc-lang-options":flags -> do
-      res <- componentOptions lvd False flags $ \opts -> mempty {
-                       ghcOptPackageDBs      = [GlobalPackageDB, UserPackageDB],
-
-                       ghcOptLanguage = ghcOptLanguage opts,
-                       ghcOptExtensions = ghcOptExtensions opts,
-                       ghcOptExtensionMap = ghcOptExtensionMap opts
-                   }
-      return $ Just $ ChResponseCompList (res ++ [(ChSetupHsName, [])])
-
-    "package-db-stack":[] -> do
-      let
-          pkgDb GlobalPackageDB = ChPkgGlobal
-          pkgDb UserPackageDB   = ChPkgUser
-          pkgDb (SpecificPackageDB s) = ChPkgSpecific s
-
-      -- TODO: Setup.hs has access to the sandbox as well: ghc-mod#478
-      return $ Just $ ChResponsePkgDbs $ map pkgDb $ withPackageDB lbi
-
-    "entrypoints":[] -> do
-#if CH_MIN_VERSION_Cabal(2,0,0)
-      includeDirMap <- recursiveDepInfo lbi v distdir
-      eps <- componentsMap lbi v distdir $ \c clbi _bi -> do
-               case needsBuildOutput includeDirMap (componentUnitId clbi) of
-                 ProduceBuildOutput -> return $ componentEntrypoints c
-                 NoBuildOutput -> return seps
-                   where (_,_,seps) = recursiveIncludeDirs includeDirMap (componentUnitId clbi)
-#else
-      eps <- componentsMap lbi v distdir $ \c _clbi _bi ->
-               return $ componentEntrypoints c
-#endif
-      -- MUST append Setup component at the end otherwise CabalHelper gets
-      -- confused
-      let eps' = eps ++ [(ChSetupHsName, ChSetupEntrypoint)]
-      return $ Just $ ChResponseEntrypoints eps'
-
-    "needs-build-output":[] -> do
-#if CH_MIN_VERSION_Cabal(2,0,0)
-      includeDirMap <- recursiveDepInfo lbi v distdir
-      nbs <- componentsMap lbi v distdir $ \c clbi _bi ->
-               return $ needsBuildOutput includeDirMap (componentUnitId clbi)
-#else
-      nbs <- componentsMap lbi v distdir $ \c _clbi _bi ->
-               return $ NoBuildOutput
-#endif
-      return $ Just $ ChResponseNeedsBuild nbs
-
-    "source-dirs":[] -> do
-      res <- componentsMap lbi v distdir $$ \_ _ bi -> return $ hsSourceDirs bi
-      return $ Just $ ChResponseCompList (res ++ [(ChSetupHsName, [])])
-
-    "print-lbi":flags ->
-      case flags of
-        ["--human"] -> print lbi >> return Nothing
-        []          -> return $ Just $ ChResponseLbi $ show lbi
-
-    cmd:_ | not (cmd `elem` commands) ->
-            errMsg ("Unknown command: " ++ cmd) >> usage >> exitFailure
-    _ ->
-            errMsg "Invalid usage!" >> usage >> exitFailure
-
-flagName' = unFlagName . flagName
-
--- getLibrary :: PackageDescription -> Library
--- getLibrary pd = unsafePerformIO $ do
---   lr <- newIORef (error "libraryMap: empty IORef")
---   withLib pd (writeIORef lr)
---   readIORef lr
-
-getLibraryClbi pd lbi = unsafePerformIO $ do
-  lr <- newIORef Nothing
-
-  withLibLBI pd lbi $ \ lib clbi ->
-      writeIORef lr $ Just (lib,clbi)
-
-  readIORef lr
-
-
-getExeClbi pd lbi = unsafePerformIO $ do
-  lr <- newIORef Nothing
-
-  withExeLBI pd lbi $ \ exe clbi ->
-      writeIORef lr $ Just (exe,clbi)
-
-  readIORef lr
-
-
-componentsMap :: LocalBuildInfo
-              -> Verbosity
-              -> FilePath
-              -> (   Component
-                  -> ComponentLocalBuildInfo
-                  -> BuildInfo
-                  -> IO a)
-              -> IO [(ChComponentName, a)]
-componentsMap lbi _v _distdir f = do
-    let pd = localPkgDescr lbi
-
-    lr <- newIORef []
-
-    -- withComponentsLBI is deprecated but also exists in very old versions
-    -- it's equivalent to withAllComponentsInBuildOrder in newer versions
-    withComponentsLBI pd lbi $ \c clbi -> do
-        let bi = componentBuildInfo c
-            name = componentNameFromComponent c
-
-        l' <- readIORef lr
-        r <- f c clbi bi
-#if CH_MIN_VERSION_Cabal(2,0,0)
-        writeIORef lr $ (componentNameToCh (unUnitId $ componentUnitId clbi) name, r):l'
-#else
-        writeIORef lr $ (componentNameToCh "" name, r):l'
-#endif
-
-    reverse <$> readIORef lr
-
-componentOptions' (lbi, v, distdir) inplaceFlag flags rf f = do
-  let pd = localPkgDescr lbi
-#if CH_MIN_VERSION_Cabal(2,0,0)
-  includeDirMap <- recursiveDepInfo lbi v distdir
-#endif
-
-  componentsMap lbi v distdir $ \c clbi bi ->
-         let
-           outdir = componentOutDir lbi c
-           (clbi', adopts) = case flags of
-                               _ | not inplaceFlag -> (clbi, mempty)
-                               ["--with-inplace"] -> (clbi, mempty)
-#if CH_MIN_VERSION_Cabal(2,0,0)
-                               [] -> removeInplaceDeps v lbi pd clbi includeDirMap
-#else
-                               [] -> removeInplaceDeps v lbi pd clbi
-#endif
-           opts = componentGhcOptions normal lbi bi clbi' outdir
-           opts' = f opts
-
-         in rf lbi v $ nubPackageFlags $ opts' `mappend` adopts
-
-componentOptions (lbi, v, distdir) inplaceFlag flags f =
-    componentOptions' (lbi, v, distdir) inplaceFlag flags renderGhcOptions' f
-
-gmModuleName :: C.ModuleName -> ChModuleName
-gmModuleName = ChModuleName . intercalate "." . components
-
-#if CH_MIN_VERSION_Cabal(2,0,0)
-removeInplaceDeps :: Verbosity
-                  -> LocalBuildInfo
-                  -> PackageDescription
-                  -> ComponentLocalBuildInfo
-                  -> Map.Map UnitId SubDeps
-                  -> (ComponentLocalBuildInfo, GhcOptions)
-removeInplaceDeps _v lbi pd clbi includeDirs = let
-    removeInplace c =
-      let
-        (ideps, incs) = partition (isInplaceCompInc c) (componentIncludes c)
-        hasIdeps' = not $ null ideps
-        c' = c { componentPackageDeps  = error "using deprecated field:componentPackageDeps"
-               , componentInternalDeps = []
-               , componentIncludes     = incs }
-      in (hasIdeps',c')
-
-    needsBuild = needsBuildOutput includeDirs (componentUnitId clbi)
-
-    cleanRecursiveOpts :: Component
-                       -> BuildInfo -> ComponentLocalBuildInfo -> GhcOptions
-    cleanRecursiveOpts comp libbi libclbi =
-      let
-        liboutdir = componentOutDir lbi comp
-        (_,libclbi') = removeInplace libclbi
-        (extraIncludes,extraDeps',_ems) = recursiveIncludeDirs includeDirs (componentUnitId libclbi)
-        (_,extraDeps) = partition (isInplaceCompInc libclbi) extraDeps'
-        opts = (componentGhcOptions normal lbi libbi libclbi' liboutdir) {
-                  ghcOptPackageDBs = []
-               }
-
-      in
-        opts { ghcOptSourcePath = ghcOptSourcePath opts <> toNubListR extraIncludes
-             , ghcOptPackages   = ghcOptPackages   opts <> toNubListR extraDeps }
-
-    libopts =
-      case (getLibraryClbi pd lbi,getExeClbi pd lbi) of
-        (Just (lib, libclbi),_) | hasIdeps ->
-          let
-            libbi = libBuildInfo lib
-            opts = cleanRecursiveOpts (CLib lib) libbi libclbi
-          in
-            opts { ghcOptInputModules = ghcOptInputModules opts <> (toNubListR $ allLibModules lib libclbi) }
-        (_,Just (exe,execlbi)) | hasIdeps ->
-          let
-            exebi = buildInfo exe
-          in
-            cleanRecursiveOpts (CExe exe) exebi execlbi
-        _ -> mempty
-
-    distDir = fromFlagOrDefault ("." </> "dist") (configDistPref $ configFlags lbi)
-    packageDbDir = internalPackageDBPath lbi distDir
-    (hasIdeps,clbi') = case needsBuild of
-                         NoBuildOutput -> removeInplace clbi
-                         ProduceBuildOutput -> (False, clbi)
-    libopts' = case needsBuild of
-                 NoBuildOutput -> libopts
-                 ProduceBuildOutput -> mempty { ghcOptPackageDBs = [SpecificPackageDB packageDbDir] }
-  in (clbi', libopts')
-#else
-removeInplaceDeps :: Verbosity
-                  -> LocalBuildInfo
-                  -> PackageDescription
-                  -> ComponentLocalBuildInfo
-                  -> (ComponentLocalBuildInfo, GhcOptions)
-removeInplaceDeps _v lbi pd clbi = let
-    (ideps, deps) = partition (isInplaceDep lbi) (componentPackageDeps clbi)
-    hasIdeps = not $ null ideps
-    libopts =
-      case getLibraryClbi pd lbi of
-        Just (lib, libclbi) | hasIdeps ->
-          let
-            libbi = libBuildInfo lib
-            liboutdir = componentOutDir lbi (CLib lib)
-          in
-            (componentGhcOptions normal lbi libbi libclbi liboutdir) {
-                ghcOptPackageDBs = []
-            }
-        _ -> mempty
-    clbi' = clbi { componentPackageDeps = deps }
-  in (clbi', libopts)
-#endif
-
-
-#if CH_MIN_VERSION_Cabal(2,0,0)
-recursiveDepInfo lbi v distdir = do
-  includeDirs <- componentsMap lbi v distdir $ \c clbi bi -> do
-    return (componentUnitId clbi
-           , ( SubDeps
-                { sdComponentInternalDeps = componentInternalDeps clbi
-                , sdHsSourceDirs          = hsSourceDirs bi
-                , sdComponentIncludes     = componentIncludes clbi
-                , sdComponentEntryPoints  = componentEntrypoints c})  )
-  return $ Map.fromList $ map snd includeDirs
-
-data SubDeps = SubDeps
-  { sdComponentInternalDeps :: [UnitId]
-  , sdHsSourceDirs          :: [FilePath]
-  , sdComponentIncludes     :: [(OpenUnitId, ModuleRenaming)]
-  , sdComponentEntryPoints  :: ChEntrypoint
-  }
-
-recursiveIncludeDirs :: Map.Map UnitId SubDeps
-                     -> UnitId -> ([FilePath], [(OpenUnitId, ModuleRenaming)]
-                                  , ChEntrypoint)
-recursiveIncludeDirs includeDirs unit = go ([],[],Nothing) [unit]
-  where
-    go (afp,aci,Nothing  ) [] = (afp,aci,error "recursiveIncludeDirs:no ChEntrypoint")
-    go (afp,aci,Just amep) [] = (afp,aci,amep)
-    go acc@(afp,aci,amep) (u:us) = case Map.lookup u includeDirs of
-      Nothing -> go acc us
-      Just (SubDeps us' sfp sci sep) -> go (afp++sfp,aci++sci,Just (combineEp amep sep)) (us++us')
-
-needsBuildOutput :: Map.Map UnitId SubDeps -> UnitId -> NeedsBuildOutput
-needsBuildOutput includeDirs unit = go [unit]
-  where
-    isIndef (IndefFullUnitId _ _) = True
-    isIndef _                     = False
-    go [] = NoBuildOutput
-    go (u:us) = case Map.lookup u includeDirs of
-      Nothing -> go us
-      Just (SubDeps us' sfp sci sep) ->
-        if any (isIndef . fst) sci
-          then ProduceBuildOutput
-          else go (us++us')
-
--- | combineEP is used to combine the entrypoints when recursively chasing
--- through the dependencies of a given entry point. The first parameter is the
--- current accumulated value, and the second one is the current sub-dependency
--- being considered. So the bias should be to preserve the type of entrypoint
--- from the first parameter.
-combineEp Nothing e = e
-combineEp (Just ChSetupEntrypoint) e = e
-combineEp (Just (ChLibEntrypoint es1 os1 ss1))   (ChLibEntrypoint es2 os2 ss2) = (ChLibEntrypoint (nub $ es2++es1) (nub $ os2++os1) (nub $ ss2++ss1))
-combineEp _                                    e@(ChExeEntrypoint  mi os2)     = error $ "combineEP: cannot have a sub exe:" ++ show e
-combineEp (Just (ChExeEntrypoint  mi os1))       (ChLibEntrypoint es2 os2 ss2) = (ChExeEntrypoint mi  (nub $ os1++es2++os2++ss2))
-
--- no, you unconditionally always wrap the result in Just, so instead of `f x = Just y; f x = Just z` do `f x = y; f x = z` and use f as `Just . f`
-
-
-
-instantiatedGhcPackage :: (ModuleName,OpenModule) -> [(OpenUnitId, ModuleRenaming)]
-instantiatedGhcPackage (_,OpenModule oui@(DefiniteUnitId _) _) = [(oui,DefaultRenaming)]
-instantiatedGhcPackage (_, _) = []
-#endif
-
-initialBuildStepsForAllComponents distdir pd lbi v =
-  initialBuildSteps distdir pd lbi v
-
-
-
-
-
-
-#if !CH_MIN_VERSION_Cabal(1,25,0)
--- CPP < 1.25
-unFlagName (FlagName n) = n
--- mkFlagName n = FlagName n
-#endif
-
-toDataVersion :: Version -> DataVersion.Version
---fromDataVersion :: DataVersion.Version -> Version
-#if CH_MIN_VERSION_Cabal(2,0,0)
-toDataVersion v = DataVersion.Version (versionNumbers v) []
---fromDataVersion (DataVersion.Version vs _) = mkVersion vs
-#else
-toDataVersion = id
---fromDataVersion = id
-#endif
-
-componentNameToCh _uid CLibName = ChLibName
-#if CH_MIN_VERSION_Cabal(1,25,0)
--- CPP >= 1.25
-#if CH_MIN_VERSION_Cabal(2,0,0)
-componentNameToCh uid (CSubLibName n) = ChSubLibName uid
-#else
-componentNameToCh _uid (CSubLibName n) = ChSubLibName (unUnqualComponentName' n)
-#endif
-componentNameToCh uid (CFLibName   n) = ChFLibName (unUnqualComponentName' n)
-#endif
-componentNameToCh _uid (CExeName n) = ChExeName (unUnqualComponentName' n)
-componentNameToCh _uid (CTestName n) = ChTestName (unUnqualComponentName' n)
-componentNameToCh _uid (CBenchName n) = ChBenchName (unUnqualComponentName' n)
-
-#if CH_MIN_VERSION_Cabal(1,25,0)
--- CPP >= 1.25
-unUnqualComponentName' = unUnqualComponentName
-#else
-unUnqualComponentName' = id
-#endif
-
-#if !CH_MIN_VERSION_Cabal(1,25,0)
--- CPP < 1.25
-componentNameFromComponent (CLib Library {}) = CLibName
-#elif CH_MIN_VERSION_Cabal(1,25,0)
--- CPP >= 1.25 (redundant)
-componentNameFromComponent (CLib Library { libName = Nothing }) = CLibName
-componentNameFromComponent (CLib Library { libName = Just n })  = CSubLibName n
-componentNameFromComponent (CFLib ForeignLib {..}) = CFLibName foreignLibName
-#endif
-componentNameFromComponent (CExe Executable {..}) = CExeName exeName
-componentNameFromComponent (CTest TestSuite {..}) = CTestName testName
-componentNameFromComponent (CBench Benchmark {..}) = CBenchName benchmarkName
-
-componentOutDir lbi (CLib Library {..})=
-    buildDir lbi
-#if CH_MIN_VERSION_Cabal(2,0,0)
-componentOutDir lbi (CFLib ForeignLib {..}) =
-    componentOutDir' lbi (unUnqualComponentName foreignLibName)
-#endif
-componentOutDir lbi (CExe Executable {..}) =
-    componentOutDir' lbi (unUnqualComponentName' exeName)
-componentOutDir lbi (CTest TestSuite { testInterface = TestSuiteExeV10 _ _, ..}) =
-    componentOutDir' lbi (unUnqualComponentName' testName)
-componentOutDir lbi (CTest TestSuite { testInterface = TestSuiteLibV09 _ _, ..}) =
-    componentOutDir' lbi (unUnqualComponentName' testName ++ "Stub")
-componentOutDir lbi (CBench Benchmark { benchmarkInterface = BenchmarkExeV10 _ _, ..})=
-    componentOutDir' lbi (unUnqualComponentName' benchmarkName)
-
-componentOutDir' :: LocalBuildInfo -> String -> FilePath
-componentOutDir' lbi compName' =
-  ----- Copied from Distribution/Simple/GHC.hs:buildOrReplExe
-  let targetDir = (buildDir lbi) </> compName'
-      compDir    = targetDir </> (compName' ++ "-tmp")
-  in compDir
-
-componentEntrypoints :: Component -> ChEntrypoint
-componentEntrypoints (CLib Library {..})
-    = ChLibEntrypoint
-        (map gmModuleName exposedModules)
-        (map gmModuleName $ otherModules libBuildInfo)
-#if CH_MIN_VERSION_Cabal(2,0,0)
-        (map gmModuleName signatures)
-#else
-        [] -- no signatures prior to Cabal 2.0
-#endif
-#if CH_MIN_VERSION_Cabal(2,0,0)
-componentEntrypoints (CFLib (ForeignLib{..}))
-    = ChLibEntrypoint
-        []
-        (map gmModuleName $ otherModules foreignLibBuildInfo)
-        []
-#endif
-componentEntrypoints (CExe Executable {..})
-    = ChExeEntrypoint
-        modulePath
-        (map gmModuleName $ otherModules buildInfo)
-componentEntrypoints (CTest TestSuite { testInterface = TestSuiteExeV10 _ fp, ..})
-    = ChExeEntrypoint fp (map gmModuleName $ otherModules testBuildInfo)
-componentEntrypoints (CTest TestSuite { testInterface = TestSuiteLibV09 _ mn, ..})
-    = ChLibEntrypoint [gmModuleName mn] (map gmModuleName $ otherModules testBuildInfo) []
-componentEntrypoints (CTest TestSuite {})
-    = ChLibEntrypoint [] [] []
-componentEntrypoints (CBench Benchmark { benchmarkInterface = BenchmarkExeV10 _  fp, ..})
-    = ChExeEntrypoint fp (map gmModuleName $ otherModules benchmarkBuildInfo)
-componentEntrypoints (CBench Benchmark {})
-    = ChLibEntrypoint [] [] []
-
-#if CH_MIN_VERSION_Cabal(2,0,0)
-isInplaceCompInc :: ComponentLocalBuildInfo -> (OpenUnitId, ModuleRenaming) -> Bool
-isInplaceCompInc clbi (DefiniteUnitId uid, _mr)     = unDefUnitId uid `elem` componentInternalDeps clbi
-isInplaceCompInc clbi (IndefFullUnitId uid _, _mmr) = False
-#endif
-
-#if CH_MIN_VERSION_Cabal(2,0,0)
-isInplaceDep :: LocalBuildInfo -> ComponentLocalBuildInfo -> (UnitId, MungedPackageId) -> Bool
-isInplaceDep lbi clbi (uid, _mpid) = uid `elem` componentInternalDeps clbi
-#else
-isInplaceDep :: LocalBuildInfo -> (InstalledPackageId, PackageId) -> Bool
-#  if CH_MIN_VERSION_Cabal(1,23,0)
--- CPP >= 1.23
-isInplaceDep lbi (ipid, _pid) = localUnitId lbi == ipid
-#  else
--- CPP <= 1.22
-isInplaceDep _lbi (ipid, pid) = inplacePackageId pid == ipid
-#  endif
-#endif
-
-#if CH_MIN_VERSION_Cabal(1,22,0)
--- CPP >= 1.22
--- >= 1.22 uses NubListR
-nubPackageFlags opts = opts
-#else
-nubPackageFlags opts = opts { ghcOptPackages = nub $ ghcOptPackages opts }
-#endif
-
-renderGhcOptions' :: LocalBuildInfo
-                  -> Verbosity
-                  -> GhcOptions
-                  -> IO [String]
-#if !CH_MIN_VERSION_Cabal(1,20,0)
-renderGhcOptions' lbi v opts = do
--- CPP < 1.20
-  (ghcProg, _) <- requireProgram v ghcProgram (withPrograms lbi)
-  let Just ghcVer = programVersion ghcProg
-  return $ renderGhcOptions ghcVer opts
-#elif CH_MIN_VERSION_Cabal(1,20,0) && !CH_MIN_VERSION_Cabal(1,24,0)
-renderGhcOptions' lbi _v opts = do
--- CPP >= 1.20 && < 1.24
-  return $ renderGhcOptions (compiler lbi) opts
-#else
-renderGhcOptions' lbi _v opts = do
--- CPP >= 1.24
-  return $ renderGhcOptions (compiler lbi) (hostPlatform lbi) opts
-#endif
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/Common.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/Common.hs
deleted file mode 100644
index a7e7377..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/Common.hs
+++ /dev/null
@@ -1,150 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-|
-Module      : CabalHelper.Shared.Common
-Description : Shared utility functions
-License     : GPL-3
--}
-
-{-# LANGUAGE CPP, DeriveDataTypeable, OverloadedStrings #-}
-module CabalHelper.Shared.Common where
-
-#ifdef MIN_VERSION_Cabal
-#undef CH_MIN_VERSION_Cabal
-#define CH_MIN_VERSION_Cabal MIN_VERSION_Cabal
-#endif
-
-import Control.Applicative
-import Control.Exception as E
-import Control.Monad
-import Data.Char
-import Data.List
-import Data.Maybe
-import Data.Version
-import Data.Typeable
-import Data.ByteString (ByteString)
-import qualified Data.ByteString as BS
-import qualified Data.ByteString.Char8 as BS8
-#if CH_MIN_VERSION_Cabal(2,2,0)
-import qualified Distribution.PackageDescription.Parsec as P
-#else
-import qualified Distribution.PackageDescription.Parse as P
-#endif
-import System.Environment
-import System.IO
-import qualified System.Info
-import System.Exit
-import System.Directory
-import System.FilePath
-import Text.ParserCombinators.ReadP
-import Prelude
-
-data Panic = Panic String deriving (Typeable, Show)
-instance Exception Panic
-
-panic :: String -> a
-panic msg = throw $ Panic msg
-
-panicIO :: String -> IO a
-panicIO msg = throwIO $ Panic msg
-
-handlePanic :: IO a -> IO a
-handlePanic action =
-    action `E.catch` \(Panic msg) -> errMsg msg >> exitFailure
-
-errMsg :: String -> IO ()
-errMsg str = do
-  prog <- getProgName
-  hPutStrLn stderr $ prog ++ ": " ++ str
-
--- | @getCabalConfigHeader "dist/setup-config"@ returns the cabal version and
--- compiler version
-getCabalConfigHeader :: FilePath -> IO (Maybe (Version, (ByteString, Version)))
-getCabalConfigHeader file = bracket (openFile file ReadMode) hClose $ \h -> do
-  parseHeader <$> BS.hGetLine h
-
-parseHeader :: ByteString -> Maybe (Version, (ByteString, Version))
-parseHeader header = case BS8.words header of
-  ["Saved", "package", "config", "for", _pkgId ,
-   "written", "by", cabalId,
-   "using", compId]
-    -> liftM2 (,) (snd <$> parsePkgId cabalId) (parsePkgId compId)
-  _ -> Nothing
-
-parsePkgId :: ByteString -> Maybe (ByteString, Version)
-parsePkgId bs =
-    case BS8.split '-' bs of
-      [pkg, vers] -> Just (pkg, parseVer $ BS8.unpack vers)
-      _ -> Nothing
-
-parseVer :: String -> Version
-parseVer vers = runReadP parseVersion vers
-
-trim :: String -> String
-trim = dropWhileEnd isSpace
-
-majorVer :: Version -> Version
-majorVer (Version b _) = Version (take 2 b) []
-
-sameMajorVersionAs :: Version -> Version -> Bool
-sameMajorVersionAs a b = majorVer a == majorVer b
-
-runReadP :: ReadP t -> String -> t
-runReadP p i = case filter ((=="") . snd) $ readP_to_S p i of
-                 (a,""):[] -> a
-                 _ -> error $ "Error parsing: " ++ show i
-
-appCacheDir :: IO FilePath
-appCacheDir =
-    (</> "cabal-helper") <$> getEnvDefault "XDG_CACHE_HOME" (homeRel cache)
- where
-    -- for GHC 7.4
-    lookupEnv' var = do env <- getEnvironment; return (lookup var env)
-    getEnvDefault var def = lookupEnv' var >>= \m -> case m of Nothing -> def; Just x -> return x
-    homeRel path = (</> path) <$> getHomeDirectory
-    cache =
-        case System.Info.os of
-          "mingw32" -> windowsCache
-          _         -> unixCache
-
-    windowsCache = "Local Settings" </> "Cache"
-    unixCache = ".cache"
-
-isCabalFile :: FilePath -> Bool
-isCabalFile f = takeExtension' f == ".cabal"
-
-takeExtension' :: FilePath -> String
-takeExtension' p =
-    if takeFileName p == takeExtension p
-      then "" -- just ".cabal" is not a valid cabal file
-      else takeExtension p
-
-replace :: String -> String -> String -> String
-replace n r hs' = go "" hs'
- where
-   go acc h
-       | take (length n) h == n =
-           reverse acc ++ r ++ drop (length n) h
-   go acc (h:hs) = go (h:acc) hs
-   go acc [] = reverse acc
-
-
-#if CH_MIN_VERSION_Cabal(2,2,0)
-readPackageDescription = P.readGenericPackageDescription
-#else
-readPackageDescription = P.readPackageDescription
-#endif
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/InterfaceTypes.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/InterfaceTypes.hs
deleted file mode 100644
index a108c72..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/InterfaceTypes.hs
+++ /dev/null
@@ -1,81 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2018  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-# LANGUAGE DeriveGeneric, DeriveDataTypeable, DefaultSignatures #-}
-
-{-|
-Module      : CabalHelper.Shared.InterfaceTypes
-Description : Types which are used by c-h library and executable to communicate
-License     : GPL-3
-
-These types are used to communicate between the cabal-helper library and main
-executable, using Show/Read. If any types in this module change the major
-version must be bumped since this will be exposed in the @Distribution.Helper@
-module.
-
-The cached executables in @$XDG_CACHE_HOME/cabal-helper@ use the cabal-helper
-version (among other things) as a cache key so we don't need to worry about
-talking to an old executable.
--}
-module CabalHelper.Shared.InterfaceTypes where
-
-import GHC.Generics
-import Data.Version
-
-data ChResponse
-    = ChResponseCompList    [(ChComponentName, [String])]
-    | ChResponseEntrypoints [(ChComponentName, ChEntrypoint)]
-    | ChResponseNeedsBuild  [(ChComponentName, NeedsBuildOutput)]
-    | ChResponseList        [String]
-    | ChResponsePkgDbs      [ChPkgDb]
-    | ChResponseLbi         String
-    | ChResponseVersion     String Version
-    | ChResponseLicenses    [(String, [(String, Version)])]
-    | ChResponseFlags       [(String, Bool)]
-  deriving (Eq, Ord, Read, Show, Generic)
-
-data ChComponentName = ChSetupHsName
-                     | ChLibName
-                     | ChSubLibName String
-                     | ChFLibName String
-                     | ChExeName String
-                     | ChTestName String
-                     | ChBenchName String
-  deriving (Eq, Ord, Read, Show, Generic)
-
-newtype ChModuleName = ChModuleName String
-    deriving (Eq, Ord, Read, Show, Generic)
-
-data ChEntrypoint = ChSetupEntrypoint -- ^ Almost like 'ChExeEntrypoint' but
-                                      -- @main-is@ could either be @"Setup.hs"@
-                                      -- or @"Setup.lhs"@. Since we don't know
-                                      -- where the source directory is you have
-                                      -- to find these files.
-                  | ChLibEntrypoint { chExposedModules :: [ChModuleName]
-                                    , chOtherModules   :: [ChModuleName]
-                                    , chSignatures     :: [ChModuleName] -- backpack only
-                                    }
-                  | ChExeEntrypoint { chMainIs         :: FilePath
-                                    , chOtherModules   :: [ChModuleName]
-                                    } deriving (Eq, Ord, Read, Show, Generic)
-
-data ChPkgDb = ChPkgGlobal
-             | ChPkgUser
-             | ChPkgSpecific FilePath
-               deriving (Eq, Ord, Read, Show, Generic)
-
-data NeedsBuildOutput = ProduceBuildOutput | NoBuildOutput
-               deriving (Eq, Ord, Read, Show, Generic)
diff --git a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/Sandbox.hs b/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/Sandbox.hs
deleted file mode 100644
index 2f3774f..0000000
--- a/vendor/cabal-helper-0.8.1.2/src/CabalHelper/Shared/Sandbox.hs
+++ /dev/null
@@ -1,78 +0,0 @@
--- cabal-helper: Simple interface to Cabal's configuration state
--- Copyright (C) 2015-2017  Daniel Gröber <cabal-helper@dxld.at>
---
--- This program is free software: you can redistribute it and/or modify
--- it under the terms of the GNU General Public License as published by
--- the Free Software Foundation, either version 3 of the License, or
--- (at your option) any later version.
---
--- This program is distributed in the hope that it will be useful,
--- but WITHOUT ANY WARRANTY; without even the implied warranty of
--- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
--- GNU General Public License for more details.
---
--- You should have received a copy of the GNU General Public License
--- along with this program.  If not, see <http://www.gnu.org/licenses/>.
-
-{-|
-Module      : CabalHelper.Shared.Sandbox
-Description : Extracting information from @cabal.sandbox.config@ files
-License     : GPL-3
--}
-
-module CabalHelper.Shared.Sandbox where
-
-import Control.Applicative
-import Data.Char
-import Data.Maybe
-import Data.List
-import Data.Version
-import System.FilePath
-import System.Directory
-import Prelude
-
-import qualified Data.Traversable as T
-
--- | Get the path to the sandbox package-db in a project
-getSandboxPkgDb :: FilePath
-             -- ^ Path to the cabal package root directory (containing the
-             -- @cabal.sandbox.config@ file)
-             -> String
-             -- ^ Cabal build platform, i.e. @buildPlatform@
-             -> Version
-             -- ^ GHC version (@cProjectVersion@ is your friend)
-             -> IO (Maybe FilePath)
-getSandboxPkgDb d platform ghcVer = do
-  mConf <- T.traverse readFile =<< mightExist (d </> "cabal.sandbox.config")
-  return $ fixPkgDbVer <$> (extractSandboxDbDir =<< mConf)
-
- where
-   fixPkgDbVer dir =
-       case takeFileName dir == ghcSandboxPkgDbDir platform ghcVer of
-         True -> dir
-         False -> takeDirectory dir </> ghcSandboxPkgDbDir platform ghcVer
-
-ghcSandboxPkgDbDir :: String -> Version -> String
-ghcSandboxPkgDbDir platform ghcVer =
-   platform ++ "-ghc-" ++ showVersion ghcVer ++ "-packages.conf.d"
-
--- | Extract the sandbox package db directory from the cabal.sandbox.config
--- file. Exception is thrown if the sandbox config file is broken.
-extractSandboxDbDir :: String -> Maybe FilePath
-extractSandboxDbDir conf = extractValue <$> parse conf
-  where
-    key = "package-db:"
-    keyLen = length key
-
-    parse = listToMaybe . filter (key `isPrefixOf`) . lines
-    extractValue = CabalHelper.Shared.Sandbox.dropWhileEnd isSpace . dropWhile isSpace . drop keyLen
-
-
-mightExist :: FilePath -> IO (Maybe FilePath)
-mightExist f = do
-  exists <- doesFileExist f
-  return $ if exists then (Just f) else (Nothing)
-
--- dropWhileEnd is not provided prior to base 4.5.0.0.
-dropWhileEnd :: (a -> Bool) -> [a] -> [a]
-dropWhileEnd p = foldr (\x xs -> if p x && null xs then [] else x : xs) []