{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE LambdaCase #-}
{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}
module GHC.Driver.Session (
DumpFlag(..),
GeneralFlag(..),
WarningFlag(..), DiagnosticReason(..),
Language(..),
FatalMessager, FlushOut(..),
ProfAuto(..),
glasgowExtsFlags,
hasPprDebug, hasNoDebugOutput, hasNoStateHack, hasNoOptCoercion,
dopt, dopt_set, dopt_unset,
gopt, gopt_set, gopt_unset, setGeneralFlag', unSetGeneralFlag',
wopt, wopt_set, wopt_unset,
wopt_fatal, wopt_set_fatal, wopt_unset_fatal,
xopt, xopt_set, xopt_unset,
xopt_set_unlessExplSpec,
xopt_DuplicateRecordFields,
xopt_FieldSelectors,
lang_set,
DynamicTooState(..), dynamicTooState, setDynamicNow,
sccProfilingEnabled,
needSourceNotes,
DynFlags(..),
outputFile, objectSuf, ways,
FlagSpec(..),
HasDynFlags(..), ContainsDynFlags(..),
RtsOptsEnabled(..),
GhcMode(..), isOneShot,
GhcLink(..), isNoLink,
PackageFlag(..), PackageArg(..), ModRenaming(..),
packageFlagsChanged,
IgnorePackageFlag(..), TrustFlag(..),
PackageDBFlag(..), PkgDbRef(..),
Option(..), showOpt,
DynLibLoader(..),
fFlags, fLangFlags, xFlags,
wWarningFlags,
makeDynFlagsConsistent,
positionIndependent,
optimisationFlags,
setFlagsFromEnvFile,
pprDynFlagsDiff,
flagSpecOf,
targetProfile,
safeHaskellOn, safeHaskellModeEnabled,
safeImportsOn, safeLanguageOn, safeInferOn,
packageTrustOn,
safeDirectImpsReq, safeImplicitImpsReq,
unsafeFlags, unsafeFlagsForInfer,
LlvmTarget(..), LlvmConfig(..),
Settings(..),
sProgramName,
sProjectVersion,
sGhcUsagePath,
sGhciUsagePath,
sToolDir,
sTopDir,
sGlobalPackageDatabasePath,
sLdSupportsCompactUnwind,
sLdSupportsBuildId,
sLdSupportsFilelist,
sLdIsGnuLd,
sGccSupportsNoPie,
sPgm_L,
sPgm_P,
sPgm_F,
sPgm_c,
sPgm_cxx,
sPgm_a,
sPgm_l,
sPgm_lm,
sPgm_dll,
sPgm_T,
sPgm_windres,
sPgm_libtool,
sPgm_ar,
sPgm_ranlib,
sPgm_lo,
sPgm_lc,
sPgm_lcc,
sPgm_i,
sOpt_L,
sOpt_P,
sOpt_P_fingerprint,
sOpt_F,
sOpt_c,
sOpt_cxx,
sOpt_a,
sOpt_l,
sOpt_lm,
sOpt_windres,
sOpt_lo,
sOpt_lc,
sOpt_lcc,
sOpt_i,
sExtraGccViaCFlags,
sTargetPlatformString,
sGhcWithInterpreter,
sLibFFI,
GhcNameVersion(..),
FileSettings(..),
PlatformMisc(..),
settings,
programName, projectVersion,
ghcUsagePath, ghciUsagePath, topDir,
versionedAppDir, versionedFilePath,
extraGccViaCFlags, globalPackageDatabasePath,
pgm_L, pgm_P, pgm_F, pgm_c, pgm_cxx, pgm_a, pgm_l, pgm_lm, pgm_dll, pgm_T,
pgm_windres, pgm_libtool, pgm_ar, pgm_otool, pgm_install_name_tool,
pgm_ranlib, pgm_lo, pgm_lc, pgm_lcc, pgm_i,
opt_L, opt_P, opt_F, opt_c, opt_cxx, opt_a, opt_l, opt_lm, opt_i,
opt_P_signature,
opt_windres, opt_lo, opt_lc, opt_lcc,
updatePlatformConstants,
addPluginModuleName,
defaultDynFlags,
initDynFlags,
defaultFatalMessager,
defaultFlushOut,
setOutputFile, setDynOutputFile, setOutputHi, setDynOutputHi,
augmentByWorkingDirectory,
getOpts,
getVerbFlags,
updOptLevel,
setTmpDir,
setUnitId,
TurnOnFlag,
turnOn,
turnOff,
impliedGFlags,
impliedOffGFlags,
impliedXFlags,
CmdLineP(..), runCmdLineP,
getCmdLineState, putCmdLineState,
processCmdLineP,
parseDynamicFlagsCmdLine,
parseDynamicFilePragma,
parseDynamicFlagsFull,
allNonDeprecatedFlags,
flagsAll,
flagsDynamic,
flagsPackage,
flagsForCompletion,
supportedLanguagesAndExtensions,
languageExtensions,
picCCOpts, picPOpts,
pieCCLDOpts,
compilerInfo,
wordAlignment,
setUnsafeGlobalDynFlags,
isSse4_2Enabled,
isBmiEnabled,
isBmi2Enabled,
isAvxEnabled,
isAvx2Enabled,
isAvx512cdEnabled,
isAvx512erEnabled,
isAvx512fEnabled,
isAvx512pfEnabled,
LinkerInfo(..),
CompilerInfo(..),
useXLinkerRPath,
IncludeSpecs(..), addGlobalInclude, addQuoteInclude, flattenIncludes,
addImplicitQuoteInclude,
initSDocContext, initDefaultSDocContext,
) where
import GHC.Prelude
import GHC.Platform
import GHC.Platform.Ways
import GHC.Platform.Profile
import GHC.UniqueSubdir (uniqueSubdir)
import GHC.Unit.Types
import GHC.Unit.Parser
import GHC.Unit.Module
import GHC.Builtin.Names ( mAIN_NAME )
import GHC.Driver.Phases ( Phase(..), phaseInputExt )
import GHC.Driver.Flags
import GHC.Driver.Backend
import GHC.Settings.Config
import GHC.Utils.CliOption
import GHC.Core.Unfold
import GHC.Driver.CmdLine
import GHC.Settings.Constants
import GHC.Utils.Panic
import qualified GHC.Utils.Ppr.Colour as Col
import GHC.Utils.Misc
import GHC.Utils.Constants (debugIsOn)
import GHC.Utils.GlobalVars
import GHC.Data.Maybe
import GHC.Data.Bool
import GHC.Utils.Monad
import GHC.Types.Error (DiagnosticReason(..))
import GHC.Types.SrcLoc
import GHC.Types.SafeHaskell
import GHC.Types.Basic ( IntWithInf, treatZeroAsInf )
import qualified GHC.Types.FieldLabel as FieldLabel
import GHC.Data.FastString
import GHC.Utils.TmpFs
import GHC.Utils.Fingerprint
import GHC.Utils.Outputable
import GHC.Settings
import GHC.CmmToAsm.CFG.Weight
import {-# SOURCE #-} GHC.Core.Opt.CallerCC
import GHC.SysTools.Terminal ( stderrSupportsAnsiColors )
import GHC.SysTools.BaseDir ( expandToolDir, expandTopDir )
import Data.IORef
import Control.Arrow ((&&&))
import Control.Monad
import Control.Monad.Trans.Class
import Control.Monad.Trans.Writer
import Control.Monad.Trans.Reader
import Control.Monad.Trans.Except
import Control.Monad.Trans.State as State
import Data.Functor.Identity
import Data.Ord
import Data.Char
import Data.List (intercalate, sortBy)
import qualified Data.List.NonEmpty as NE
import qualified Data.Map as Map
import qualified Data.Set as Set
import System.FilePath
import System.Directory
import System.Environment (lookupEnv)
import System.IO
import System.IO.Error
import Text.ParserCombinators.ReadP hiding (char)
import Text.ParserCombinators.ReadP as R
import GHC.Data.EnumSet (EnumSet)
import qualified GHC.Data.EnumSet as EnumSet
import GHC.Foreign (withCString, peekCString)
import qualified GHC.LanguageExtensions as LangExt
data IncludeSpecs
= IncludeSpecs { IncludeSpecs -> [[Char]]
includePathsQuote :: [String]
, IncludeSpecs -> [[Char]]
includePathsGlobal :: [String]
, IncludeSpecs -> [[Char]]
includePathsQuoteImplicit :: [String]
}
deriving Int -> IncludeSpecs -> ShowS
[IncludeSpecs] -> ShowS
IncludeSpecs -> [Char]
(Int -> IncludeSpecs -> ShowS)
-> (IncludeSpecs -> [Char])
-> ([IncludeSpecs] -> ShowS)
-> Show IncludeSpecs
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IncludeSpecs -> ShowS
showsPrec :: Int -> IncludeSpecs -> ShowS
$cshow :: IncludeSpecs -> [Char]
show :: IncludeSpecs -> [Char]
$cshowList :: [IncludeSpecs] -> ShowS
showList :: [IncludeSpecs] -> ShowS
Show
addGlobalInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addGlobalInclude :: IncludeSpecs -> [[Char]] -> IncludeSpecs
addGlobalInclude IncludeSpecs
spec [[Char]]
paths = let f :: [[Char]]
f = IncludeSpecs -> [[Char]]
includePathsGlobal IncludeSpecs
spec
in IncludeSpecs
spec { includePathsGlobal :: [[Char]]
includePathsGlobal = [[Char]]
f [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]]
paths }
addQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addQuoteInclude :: IncludeSpecs -> [[Char]] -> IncludeSpecs
addQuoteInclude IncludeSpecs
spec [[Char]]
paths = let f :: [[Char]]
f = IncludeSpecs -> [[Char]]
includePathsQuote IncludeSpecs
spec
in IncludeSpecs
spec { includePathsQuote :: [[Char]]
includePathsQuote = [[Char]]
f [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]]
paths }
addImplicitQuoteInclude :: IncludeSpecs -> [String] -> IncludeSpecs
addImplicitQuoteInclude :: IncludeSpecs -> [[Char]] -> IncludeSpecs
addImplicitQuoteInclude IncludeSpecs
spec [[Char]]
paths = let f :: [[Char]]
f = IncludeSpecs -> [[Char]]
includePathsQuoteImplicit IncludeSpecs
spec
in IncludeSpecs
spec { includePathsQuoteImplicit :: [[Char]]
includePathsQuoteImplicit = [[Char]]
f [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ [[Char]]
paths }
flattenIncludes :: IncludeSpecs -> [String]
flattenIncludes :: IncludeSpecs -> [[Char]]
flattenIncludes IncludeSpecs
specs =
IncludeSpecs -> [[Char]]
includePathsQuote IncludeSpecs
specs [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++
IncludeSpecs -> [[Char]]
includePathsQuoteImplicit IncludeSpecs
specs [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++
IncludeSpecs -> [[Char]]
includePathsGlobal IncludeSpecs
specs
data DynFlags = DynFlags {
DynFlags -> GhcMode
ghcMode :: GhcMode,
DynFlags -> GhcLink
ghcLink :: GhcLink,
DynFlags -> Backend
backend :: !Backend,
DynFlags -> GhcNameVersion
ghcNameVersion :: {-# UNPACK #-} !GhcNameVersion,
DynFlags -> FileSettings
fileSettings :: {-# UNPACK #-} !FileSettings,
DynFlags -> Platform
targetPlatform :: Platform,
DynFlags -> ToolSettings
toolSettings :: {-# UNPACK #-} !ToolSettings,
DynFlags -> PlatformMisc
platformMisc :: {-# UNPACK #-} !PlatformMisc,
DynFlags -> [([Char], [Char])]
rawSettings :: [(String, String)],
DynFlags -> TempDir
tmpDir :: TempDir,
DynFlags -> LlvmConfig
llvmConfig :: LlvmConfig,
DynFlags -> Int
llvmOptLevel :: Int,
DynFlags -> Int
verbosity :: Int,
DynFlags -> Int
debugLevel :: Int,
DynFlags -> Int
simplPhases :: Int,
DynFlags -> Int
maxSimplIterations :: Int,
DynFlags -> Maybe [Char]
ruleCheck :: Maybe String,
DynFlags -> [Int]
strictnessBefore :: [Int],
DynFlags -> Maybe Int
parMakeCount :: Maybe Int,
DynFlags -> Bool
enableTimeStats :: Bool,
DynFlags -> Maybe Int
ghcHeapSize :: Maybe Int,
DynFlags -> Maybe Int
maxRelevantBinds :: Maybe Int,
DynFlags -> Maybe Int
maxValidHoleFits :: Maybe Int,
DynFlags -> Maybe Int
maxRefHoleFits :: Maybe Int,
DynFlags -> Maybe Int
refLevelHoleFits :: Maybe Int,
DynFlags -> Int
maxUncoveredPatterns :: Int,
DynFlags -> Int
maxPmCheckModels :: Int,
DynFlags -> Int
simplTickFactor :: Int,
DynFlags -> Int
dmdUnboxWidth :: !Int,
DynFlags -> Maybe Int
specConstrThreshold :: Maybe Int,
DynFlags -> Maybe Int
specConstrCount :: Maybe Int,
DynFlags -> Int
specConstrRecursive :: Int,
DynFlags -> Maybe Word
binBlobThreshold :: Maybe Word,
DynFlags -> Maybe Int
liberateCaseThreshold :: Maybe Int,
DynFlags -> Maybe Int
floatLamArgs :: Maybe Int,
DynFlags -> Maybe Int
liftLamsRecArgs :: Maybe Int,
DynFlags -> Maybe Int
liftLamsNonRecArgs :: Maybe Int,
DynFlags -> Bool
liftLamsKnown :: Bool,
DynFlags -> Maybe Int
cmmProcAlignment :: Maybe Int,
DynFlags -> Int
historySize :: Int,
DynFlags -> [[Char]]
importPaths :: [FilePath],
DynFlags -> ModuleName
mainModuleNameIs :: ModuleName,
DynFlags -> Maybe [Char]
mainFunIs :: Maybe String,
DynFlags -> IntWithInf
reductionDepth :: IntWithInf,
DynFlags -> IntWithInf
solverIterations :: IntWithInf,
DynFlags -> UnitId
homeUnitId_ :: UnitId,
DynFlags -> Maybe UnitId
homeUnitInstanceOf_ :: Maybe UnitId,
DynFlags -> [(ModuleName, Module)]
homeUnitInstantiations_ :: [(ModuleName, Module)],
DynFlags -> Maybe [Char]
workingDirectory :: Maybe FilePath,
DynFlags -> Maybe [Char]
thisPackageName :: Maybe String,
DynFlags -> Set ModuleName
hiddenModules :: Set.Set ModuleName,
DynFlags -> Set ModuleName
reexportedModules :: Set.Set ModuleName,
DynFlags -> Ways
targetWays_ :: Ways,
DynFlags -> Maybe ([Char], Int)
splitInfo :: Maybe (String,Int),
DynFlags -> Maybe [Char]
objectDir :: Maybe String,
DynFlags -> Maybe [Char]
dylibInstallName :: Maybe String,
DynFlags -> Maybe [Char]
hiDir :: Maybe String,
DynFlags -> Maybe [Char]
hieDir :: Maybe String,
DynFlags -> Maybe [Char]
stubDir :: Maybe String,
DynFlags -> Maybe [Char]
dumpDir :: Maybe String,
DynFlags -> [Char]
objectSuf_ :: String,
DynFlags -> [Char]
hcSuf :: String,
DynFlags -> [Char]
hiSuf_ :: String,
DynFlags -> [Char]
hieSuf :: String,
DynFlags -> [Char]
dynObjectSuf_ :: String,
DynFlags -> [Char]
dynHiSuf_ :: String,
DynFlags -> Maybe [Char]
outputFile_ :: Maybe String,
DynFlags -> Maybe [Char]
dynOutputFile_ :: Maybe String,
DynFlags -> Maybe [Char]
outputHi :: Maybe String,
DynFlags -> Maybe [Char]
dynOutputHi :: Maybe String,
DynFlags -> DynLibLoader
dynLibLoader :: DynLibLoader,
DynFlags -> Bool
dynamicNow :: !Bool,
DynFlags -> [Char]
dumpPrefix :: FilePath,
DynFlags -> Maybe [Char]
dumpPrefixForce :: Maybe FilePath,
DynFlags -> [Option]
ldInputs :: [Option],
DynFlags -> IncludeSpecs
includePaths :: IncludeSpecs,
DynFlags -> [[Char]]
libraryPaths :: [String],
DynFlags -> [[Char]]
frameworkPaths :: [String],
DynFlags -> [[Char]]
cmdlineFrameworks :: [String],
DynFlags -> Maybe [Char]
rtsOpts :: Maybe String,
DynFlags -> RtsOptsEnabled
rtsOptsEnabled :: RtsOptsEnabled,
DynFlags -> Bool
rtsOptsSuggestions :: Bool,
DynFlags -> [Char]
hpcDir :: String,
DynFlags -> [ModuleName]
pluginModNames :: [ModuleName],
DynFlags -> [(ModuleName, [Char])]
pluginModNameOpts :: [(ModuleName,String)],
DynFlags -> [[Char]]
frontendPluginOpts :: [String],
DynFlags -> [Char]
depMakefile :: FilePath,
DynFlags -> Bool
depIncludePkgDeps :: Bool,
DynFlags -> Bool
depIncludeCppDeps :: Bool,
DynFlags -> [ModuleName]
depExcludeMods :: [ModuleName],
DynFlags -> [[Char]]
depSuffixes :: [String],
DynFlags -> [PackageDBFlag]
packageDBFlags :: [PackageDBFlag],
DynFlags -> [IgnorePackageFlag]
ignorePackageFlags :: [IgnorePackageFlag],
DynFlags -> [PackageFlag]
packageFlags :: [PackageFlag],
DynFlags -> [PackageFlag]
pluginPackageFlags :: [PackageFlag],
DynFlags -> [TrustFlag]
trustFlags :: [TrustFlag],
DynFlags -> Maybe [Char]
packageEnv :: Maybe FilePath,
DynFlags -> EnumSet DumpFlag
dumpFlags :: EnumSet DumpFlag,
DynFlags -> EnumSet GeneralFlag
generalFlags :: EnumSet GeneralFlag,
DynFlags -> EnumSet WarningFlag
warningFlags :: EnumSet WarningFlag,
DynFlags -> EnumSet WarningFlag
fatalWarningFlags :: EnumSet WarningFlag,
DynFlags -> Maybe Language
language :: Maybe Language,
DynFlags -> SafeHaskellMode
safeHaskell :: SafeHaskellMode,
DynFlags -> Bool
safeInfer :: Bool,
DynFlags -> Bool
safeInferred :: Bool,
DynFlags -> SrcSpan
thOnLoc :: SrcSpan,
DynFlags -> SrcSpan
newDerivOnLoc :: SrcSpan,
DynFlags -> SrcSpan
deriveViaOnLoc :: SrcSpan,
DynFlags -> SrcSpan
overlapInstLoc :: SrcSpan,
DynFlags -> SrcSpan
incoherentOnLoc :: SrcSpan,
DynFlags -> SrcSpan
pkgTrustOnLoc :: SrcSpan,
DynFlags -> SrcSpan
warnSafeOnLoc :: SrcSpan,
DynFlags -> SrcSpan
warnUnsafeOnLoc :: SrcSpan,
DynFlags -> SrcSpan
trustworthyOnLoc :: SrcSpan,
DynFlags -> [OnOff Extension]
extensions :: [OnOff LangExt.Extension],
DynFlags -> EnumSet Extension
extensionFlags :: EnumSet LangExt.Extension,
DynFlags -> UnfoldingOpts
unfoldingOpts :: !UnfoldingOpts,
DynFlags -> Int
maxWorkerArgs :: Int,
DynFlags -> Int
ghciHistSize :: Int,
DynFlags -> FlushOut
flushOut :: FlushOut,
DynFlags -> Maybe [Char]
ghcVersionFile :: Maybe FilePath,
DynFlags -> Maybe [Char]
haddockOptions :: Maybe String,
DynFlags -> [[Char]]
ghciScripts :: [String],
DynFlags -> Int
pprUserLength :: Int,
DynFlags -> Int
pprCols :: Int,
DynFlags -> Bool
useUnicode :: Bool,
DynFlags -> OverridingBool
useColor :: OverridingBool,
DynFlags -> Bool
canUseColor :: Bool,
DynFlags -> Scheme
colScheme :: Col.Scheme,
DynFlags -> ProfAuto
profAuto :: ProfAuto,
DynFlags -> [CallerCcFilter]
callerCcFilters :: [CallerCcFilter],
DynFlags -> Maybe [Char]
interactivePrint :: Maybe String,
DynFlags -> Maybe SseVersion
sseVersion :: Maybe SseVersion,
DynFlags -> Maybe BmiVersion
bmiVersion :: Maybe BmiVersion,
DynFlags -> Bool
avx :: Bool,
DynFlags -> Bool
avx2 :: Bool,
DynFlags -> Bool
avx512cd :: Bool,
DynFlags -> Bool
avx512er :: Bool,
DynFlags -> Bool
avx512f :: Bool,
DynFlags -> Bool
avx512pf :: Bool,
DynFlags -> IORef (Maybe LinkerInfo)
rtldInfo :: IORef (Maybe LinkerInfo),
DynFlags -> IORef (Maybe CompilerInfo)
rtccInfo :: IORef (Maybe CompilerInfo),
DynFlags -> IORef (Maybe CompilerInfo)
rtasmInfo :: IORef (Maybe CompilerInfo),
DynFlags -> Int
maxInlineAllocSize :: Int,
DynFlags -> Int
maxInlineMemcpyInsns :: Int,
DynFlags -> Int
maxInlineMemsetInsns :: Int,
DynFlags -> Bool
reverseErrors :: Bool,
DynFlags -> Maybe Int
maxErrors :: Maybe Int,
DynFlags -> Word
initialUnique :: Word,
DynFlags -> Int
uniqueIncrement :: Int,
DynFlags -> Weights
cfgWeights :: Weights
}
class HasDynFlags m where
getDynFlags :: m DynFlags
instance (Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) where
getDynFlags :: WriterT a m DynFlags
getDynFlags = m DynFlags -> WriterT a m DynFlags
forall (m :: * -> *) a. Monad m => m a -> WriterT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
instance (Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m) where
getDynFlags :: ReaderT a m DynFlags
getDynFlags = m DynFlags -> ReaderT a m DynFlags
forall (m :: * -> *) a. Monad m => m a -> ReaderT a m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
instance (Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) where
getDynFlags :: MaybeT m DynFlags
getDynFlags = m DynFlags -> MaybeT m DynFlags
forall (m :: * -> *) a. Monad m => m a -> MaybeT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
instance (Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) where
getDynFlags :: ExceptT e m DynFlags
getDynFlags = m DynFlags -> ExceptT e m DynFlags
forall (m :: * -> *) a. Monad m => m a -> ExceptT e m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift m DynFlags
forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags
class ContainsDynFlags t where
:: t -> DynFlags
data ProfAuto
= NoProfAuto
| ProfAutoAll
| ProfAutoTop
| ProfAutoExports
| ProfAutoCalls
deriving (ProfAuto -> ProfAuto -> Bool
(ProfAuto -> ProfAuto -> Bool)
-> (ProfAuto -> ProfAuto -> Bool) -> Eq ProfAuto
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ProfAuto -> ProfAuto -> Bool
== :: ProfAuto -> ProfAuto -> Bool
$c/= :: ProfAuto -> ProfAuto -> Bool
/= :: ProfAuto -> ProfAuto -> Bool
Eq,Int -> ProfAuto
ProfAuto -> Int
ProfAuto -> [ProfAuto]
ProfAuto -> ProfAuto
ProfAuto -> ProfAuto -> [ProfAuto]
ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto]
(ProfAuto -> ProfAuto)
-> (ProfAuto -> ProfAuto)
-> (Int -> ProfAuto)
-> (ProfAuto -> Int)
-> (ProfAuto -> [ProfAuto])
-> (ProfAuto -> ProfAuto -> [ProfAuto])
-> (ProfAuto -> ProfAuto -> [ProfAuto])
-> (ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto])
-> Enum ProfAuto
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ProfAuto -> ProfAuto
succ :: ProfAuto -> ProfAuto
$cpred :: ProfAuto -> ProfAuto
pred :: ProfAuto -> ProfAuto
$ctoEnum :: Int -> ProfAuto
toEnum :: Int -> ProfAuto
$cfromEnum :: ProfAuto -> Int
fromEnum :: ProfAuto -> Int
$cenumFrom :: ProfAuto -> [ProfAuto]
enumFrom :: ProfAuto -> [ProfAuto]
$cenumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto]
enumFromThen :: ProfAuto -> ProfAuto -> [ProfAuto]
$cenumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto]
enumFromTo :: ProfAuto -> ProfAuto -> [ProfAuto]
$cenumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto]
enumFromThenTo :: ProfAuto -> ProfAuto -> ProfAuto -> [ProfAuto]
Enum)
data LlvmTarget = LlvmTarget
{ LlvmTarget -> [Char]
lDataLayout :: String
, LlvmTarget -> [Char]
lCPU :: String
, LlvmTarget -> [[Char]]
lAttributes :: [String]
}
data LlvmConfig = LlvmConfig { LlvmConfig -> [([Char], LlvmTarget)]
llvmTargets :: [(String, LlvmTarget)]
, LlvmConfig -> [(Int, [Char])]
llvmPasses :: [(Int, String)]
}
settings :: DynFlags -> Settings
settings :: DynFlags -> Settings
settings DynFlags
dflags = Settings
{ sGhcNameVersion :: GhcNameVersion
sGhcNameVersion = DynFlags -> GhcNameVersion
ghcNameVersion DynFlags
dflags
, sFileSettings :: FileSettings
sFileSettings = DynFlags -> FileSettings
fileSettings DynFlags
dflags
, sTargetPlatform :: Platform
sTargetPlatform = DynFlags -> Platform
targetPlatform DynFlags
dflags
, sToolSettings :: ToolSettings
sToolSettings = DynFlags -> ToolSettings
toolSettings DynFlags
dflags
, sPlatformMisc :: PlatformMisc
sPlatformMisc = DynFlags -> PlatformMisc
platformMisc DynFlags
dflags
, sRawSettings :: [([Char], [Char])]
sRawSettings = DynFlags -> [([Char], [Char])]
rawSettings DynFlags
dflags
}
programName :: DynFlags -> String
programName :: DynFlags -> [Char]
programName DynFlags
dflags = GhcNameVersion -> [Char]
ghcNameVersion_programName (GhcNameVersion -> [Char]) -> GhcNameVersion -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> GhcNameVersion
ghcNameVersion DynFlags
dflags
projectVersion :: DynFlags -> String
projectVersion :: DynFlags -> [Char]
projectVersion DynFlags
dflags = GhcNameVersion -> [Char]
ghcNameVersion_projectVersion (DynFlags -> GhcNameVersion
ghcNameVersion DynFlags
dflags)
ghcUsagePath :: DynFlags -> FilePath
ghcUsagePath :: DynFlags -> [Char]
ghcUsagePath DynFlags
dflags = FileSettings -> [Char]
fileSettings_ghcUsagePath (FileSettings -> [Char]) -> FileSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
ghciUsagePath :: DynFlags -> FilePath
ghciUsagePath :: DynFlags -> [Char]
ghciUsagePath DynFlags
dflags = FileSettings -> [Char]
fileSettings_ghciUsagePath (FileSettings -> [Char]) -> FileSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
toolDir :: DynFlags -> Maybe FilePath
toolDir :: DynFlags -> Maybe [Char]
toolDir DynFlags
dflags = FileSettings -> Maybe [Char]
fileSettings_toolDir (FileSettings -> Maybe [Char]) -> FileSettings -> Maybe [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
topDir :: DynFlags -> FilePath
topDir :: DynFlags -> [Char]
topDir DynFlags
dflags = FileSettings -> [Char]
fileSettings_topDir (FileSettings -> [Char]) -> FileSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
extraGccViaCFlags :: DynFlags -> [String]
DynFlags
dflags = ToolSettings -> [[Char]]
toolSettings_extraGccViaCFlags (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
globalPackageDatabasePath :: DynFlags -> FilePath
globalPackageDatabasePath :: DynFlags -> [Char]
globalPackageDatabasePath DynFlags
dflags = FileSettings -> [Char]
fileSettings_globalPackageDatabase (FileSettings -> [Char]) -> FileSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
pgm_L :: DynFlags -> String
pgm_L :: DynFlags -> [Char]
pgm_L DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_L (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_P :: DynFlags -> (String,[Option])
pgm_P :: DynFlags -> ([Char], [Option])
pgm_P DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_P (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_F :: DynFlags -> String
pgm_F :: DynFlags -> [Char]
pgm_F DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_F (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_c :: DynFlags -> String
pgm_c :: DynFlags -> [Char]
pgm_c DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_c (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_cxx :: DynFlags -> String
pgm_cxx :: DynFlags -> [Char]
pgm_cxx DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_cxx (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_a :: DynFlags -> (String,[Option])
pgm_a :: DynFlags -> ([Char], [Option])
pgm_a DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_a (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_l :: DynFlags -> (String,[Option])
pgm_l :: DynFlags -> ([Char], [Option])
pgm_l DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_l (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lm :: DynFlags -> Maybe (String,[Option])
pgm_lm :: DynFlags -> Maybe ([Char], [Option])
pgm_lm DynFlags
dflags = ToolSettings -> Maybe ([Char], [Option])
toolSettings_pgm_lm (ToolSettings -> Maybe ([Char], [Option]))
-> ToolSettings -> Maybe ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_dll :: DynFlags -> (String,[Option])
pgm_dll :: DynFlags -> ([Char], [Option])
pgm_dll DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_dll (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_T :: DynFlags -> String
pgm_T :: DynFlags -> [Char]
pgm_T DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_T (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_windres :: DynFlags -> String
pgm_windres :: DynFlags -> [Char]
pgm_windres DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_windres (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_libtool :: DynFlags -> String
pgm_libtool :: DynFlags -> [Char]
pgm_libtool DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_libtool (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lcc :: DynFlags -> (String,[Option])
pgm_lcc :: DynFlags -> ([Char], [Option])
pgm_lcc DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_lcc (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_ar :: DynFlags -> String
pgm_ar :: DynFlags -> [Char]
pgm_ar DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_ar (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_otool :: DynFlags -> String
pgm_otool :: DynFlags -> [Char]
pgm_otool DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_otool (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_install_name_tool :: DynFlags -> String
pgm_install_name_tool :: DynFlags -> [Char]
pgm_install_name_tool DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_install_name_tool (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_ranlib :: DynFlags -> String
pgm_ranlib :: DynFlags -> [Char]
pgm_ranlib DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_ranlib (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lo :: DynFlags -> (String,[Option])
pgm_lo :: DynFlags -> ([Char], [Option])
pgm_lo DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_lo (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lc :: DynFlags -> (String,[Option])
pgm_lc :: DynFlags -> ([Char], [Option])
pgm_lc DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_lc (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_i :: DynFlags -> String
pgm_i :: DynFlags -> [Char]
pgm_i DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_i (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_L :: DynFlags -> [String]
opt_L :: DynFlags -> [[Char]]
opt_L DynFlags
dflags = ToolSettings -> [[Char]]
toolSettings_opt_L (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_P :: DynFlags -> [String]
opt_P :: DynFlags -> [[Char]]
opt_P DynFlags
dflags = (Way -> [[Char]]) -> Ways -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Ways
ways DynFlags
dflags)
[[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_P (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_P_signature :: DynFlags -> ([String], Fingerprint)
opt_P_signature :: DynFlags -> ([[Char]], Fingerprint)
opt_P_signature DynFlags
dflags =
( (Way -> [[Char]]) -> Ways -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Ways
ways DynFlags
dflags)
, ToolSettings -> Fingerprint
toolSettings_opt_P_fingerprint (ToolSettings -> Fingerprint) -> ToolSettings -> Fingerprint
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
)
opt_F :: DynFlags -> [String]
opt_F :: DynFlags -> [[Char]]
opt_F DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_F (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_c :: DynFlags -> [String]
opt_c :: DynFlags -> [[Char]]
opt_c DynFlags
dflags = (Way -> [[Char]]) -> Ways -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptc (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Ways
ways DynFlags
dflags)
[[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_c (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_cxx :: DynFlags -> [String]
opt_cxx :: DynFlags -> [[Char]]
opt_cxx DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_cxx (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_a :: DynFlags -> [String]
opt_a :: DynFlags -> [[Char]]
opt_a DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_a (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_l :: DynFlags -> [String]
opt_l :: DynFlags -> [[Char]]
opt_l DynFlags
dflags = (Way -> [[Char]]) -> Ways -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptl (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Ways
ways DynFlags
dflags)
[[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_l (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_lm :: DynFlags -> [String]
opt_lm :: DynFlags -> [[Char]]
opt_lm DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lm (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_windres :: DynFlags -> [String]
opt_windres :: DynFlags -> [[Char]]
opt_windres DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_windres (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_lcc :: DynFlags -> [String]
opt_lcc :: DynFlags -> [[Char]]
opt_lcc DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lcc (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_lo :: DynFlags -> [String]
opt_lo :: DynFlags -> [[Char]]
opt_lo DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lo (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_lc :: DynFlags -> [String]
opt_lc :: DynFlags -> [[Char]]
opt_lc DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lc (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_i :: DynFlags -> [String]
opt_i :: DynFlags -> [[Char]]
opt_i DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_i (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
versionedAppDir :: String -> ArchOS -> MaybeT IO FilePath
versionedAppDir :: [Char] -> ArchOS -> MaybeT IO [Char]
versionedAppDir [Char]
appname ArchOS
platform = do
[MaybeT IO [Char]] -> MaybeT IO [Char]
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum ([MaybeT IO [Char]] -> MaybeT IO [Char])
-> [MaybeT IO [Char]] -> MaybeT IO [Char]
forall a b. (a -> b) -> a -> b
$ (MaybeT IO [Char] -> MaybeT IO [Char])
-> [MaybeT IO [Char]] -> [MaybeT IO [Char]]
forall a b. (a -> b) -> [a] -> [b]
map ([Char] -> MaybeT IO [Char]
checkIfExists ([Char] -> MaybeT IO [Char])
-> (MaybeT IO [Char] -> MaybeT IO [Char])
-> MaybeT IO [Char]
-> MaybeT IO [Char]
forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< ShowS -> MaybeT IO [Char] -> MaybeT IO [Char]
forall a b. (a -> b) -> MaybeT IO a -> MaybeT IO b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> ShowS
</> ArchOS -> [Char]
versionedFilePath ArchOS
platform))
[ IO [Char] -> MaybeT IO [Char]
forall a. IO a -> MaybeT IO a
tryMaybeT (IO [Char] -> MaybeT IO [Char]) -> IO [Char] -> MaybeT IO [Char]
forall a b. (a -> b) -> a -> b
$ [Char] -> IO [Char]
getAppUserDataDirectory [Char]
appname
, IO [Char] -> MaybeT IO [Char]
forall a. IO a -> MaybeT IO a
tryMaybeT (IO [Char] -> MaybeT IO [Char]) -> IO [Char] -> MaybeT IO [Char]
forall a b. (a -> b) -> a -> b
$ XdgDirectory -> [Char] -> IO [Char]
getXdgDirectory XdgDirectory
XdgData [Char]
appname
]
where
checkIfExists :: [Char] -> MaybeT IO [Char]
checkIfExists [Char]
dir = IO Bool -> MaybeT IO Bool
forall a. IO a -> MaybeT IO a
tryMaybeT ([Char] -> IO Bool
doesDirectoryExist [Char]
dir) MaybeT IO Bool -> (Bool -> MaybeT IO [Char]) -> MaybeT IO [Char]
forall a b. MaybeT IO a -> (a -> MaybeT IO b) -> MaybeT IO b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
Bool
True -> [Char] -> MaybeT IO [Char]
forall a. a -> MaybeT IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
dir
Bool
False -> IO (Maybe [Char]) -> MaybeT IO [Char]
forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (Maybe [Char] -> IO (Maybe [Char])
forall a. a -> IO a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe [Char]
forall a. Maybe a
Nothing)
versionedFilePath :: ArchOS -> FilePath
versionedFilePath :: ArchOS -> [Char]
versionedFilePath ArchOS
platform = ArchOS -> [Char]
uniqueSubdir ArchOS
platform
data GhcMode
= CompManager
| OneShot
| MkDepend
deriving GhcMode -> GhcMode -> Bool
(GhcMode -> GhcMode -> Bool)
-> (GhcMode -> GhcMode -> Bool) -> Eq GhcMode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GhcMode -> GhcMode -> Bool
== :: GhcMode -> GhcMode -> Bool
$c/= :: GhcMode -> GhcMode -> Bool
/= :: GhcMode -> GhcMode -> Bool
Eq
instance Outputable GhcMode where
ppr :: GhcMode -> SDoc
ppr GhcMode
CompManager = [Char] -> SDoc
text [Char]
"CompManager"
ppr GhcMode
OneShot = [Char] -> SDoc
text [Char]
"OneShot"
ppr GhcMode
MkDepend = [Char] -> SDoc
text [Char]
"MkDepend"
isOneShot :: GhcMode -> Bool
isOneShot :: GhcMode -> Bool
isOneShot GhcMode
OneShot = Bool
True
isOneShot GhcMode
_other = Bool
False
data GhcLink
= NoLink
| LinkBinary
| LinkInMemory
| LinkDynLib
| LinkStaticLib
| LinkMergedObj
deriving (GhcLink -> GhcLink -> Bool
(GhcLink -> GhcLink -> Bool)
-> (GhcLink -> GhcLink -> Bool) -> Eq GhcLink
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: GhcLink -> GhcLink -> Bool
== :: GhcLink -> GhcLink -> Bool
$c/= :: GhcLink -> GhcLink -> Bool
/= :: GhcLink -> GhcLink -> Bool
Eq, Int -> GhcLink -> ShowS
[GhcLink] -> ShowS
GhcLink -> [Char]
(Int -> GhcLink -> ShowS)
-> (GhcLink -> [Char]) -> ([GhcLink] -> ShowS) -> Show GhcLink
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> GhcLink -> ShowS
showsPrec :: Int -> GhcLink -> ShowS
$cshow :: GhcLink -> [Char]
show :: GhcLink -> [Char]
$cshowList :: [GhcLink] -> ShowS
showList :: [GhcLink] -> ShowS
Show)
isNoLink :: GhcLink -> Bool
isNoLink :: GhcLink -> Bool
isNoLink GhcLink
NoLink = Bool
True
isNoLink GhcLink
_ = Bool
False
data PackageArg =
PackageArg String
| UnitIdArg Unit
deriving (PackageArg -> PackageArg -> Bool
(PackageArg -> PackageArg -> Bool)
-> (PackageArg -> PackageArg -> Bool) -> Eq PackageArg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackageArg -> PackageArg -> Bool
== :: PackageArg -> PackageArg -> Bool
$c/= :: PackageArg -> PackageArg -> Bool
/= :: PackageArg -> PackageArg -> Bool
Eq, Int -> PackageArg -> ShowS
[PackageArg] -> ShowS
PackageArg -> [Char]
(Int -> PackageArg -> ShowS)
-> (PackageArg -> [Char])
-> ([PackageArg] -> ShowS)
-> Show PackageArg
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PackageArg -> ShowS
showsPrec :: Int -> PackageArg -> ShowS
$cshow :: PackageArg -> [Char]
show :: PackageArg -> [Char]
$cshowList :: [PackageArg] -> ShowS
showList :: [PackageArg] -> ShowS
Show)
instance Outputable PackageArg where
ppr :: PackageArg -> SDoc
ppr (PackageArg [Char]
pn) = [Char] -> SDoc
text [Char]
"package" SDoc -> SDoc -> SDoc
<+> [Char] -> SDoc
text [Char]
pn
ppr (UnitIdArg Unit
uid) = [Char] -> SDoc
text [Char]
"unit" SDoc -> SDoc -> SDoc
<+> Unit -> SDoc
forall a. Outputable a => a -> SDoc
ppr Unit
uid
data ModRenaming = ModRenaming {
ModRenaming -> Bool
modRenamingWithImplicit :: Bool,
ModRenaming -> [(ModuleName, ModuleName)]
modRenamings :: [(ModuleName, ModuleName)]
} deriving (ModRenaming -> ModRenaming -> Bool
(ModRenaming -> ModRenaming -> Bool)
-> (ModRenaming -> ModRenaming -> Bool) -> Eq ModRenaming
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ModRenaming -> ModRenaming -> Bool
== :: ModRenaming -> ModRenaming -> Bool
$c/= :: ModRenaming -> ModRenaming -> Bool
/= :: ModRenaming -> ModRenaming -> Bool
Eq)
instance Outputable ModRenaming where
ppr :: ModRenaming -> SDoc
ppr (ModRenaming Bool
b [(ModuleName, ModuleName)]
rns) = Bool -> SDoc
forall a. Outputable a => a -> SDoc
ppr Bool
b SDoc -> SDoc -> SDoc
<+> SDoc -> SDoc
parens ([(ModuleName, ModuleName)] -> SDoc
forall a. Outputable a => a -> SDoc
ppr [(ModuleName, ModuleName)]
rns)
newtype IgnorePackageFlag = IgnorePackage String
deriving (IgnorePackageFlag -> IgnorePackageFlag -> Bool
(IgnorePackageFlag -> IgnorePackageFlag -> Bool)
-> (IgnorePackageFlag -> IgnorePackageFlag -> Bool)
-> Eq IgnorePackageFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
== :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
$c/= :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
/= :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
Eq)
data TrustFlag
= TrustPackage String
| DistrustPackage String
deriving (TrustFlag -> TrustFlag -> Bool
(TrustFlag -> TrustFlag -> Bool)
-> (TrustFlag -> TrustFlag -> Bool) -> Eq TrustFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: TrustFlag -> TrustFlag -> Bool
== :: TrustFlag -> TrustFlag -> Bool
$c/= :: TrustFlag -> TrustFlag -> Bool
/= :: TrustFlag -> TrustFlag -> Bool
Eq)
data PackageFlag
= ExposePackage String PackageArg ModRenaming
| HidePackage String
deriving (PackageFlag -> PackageFlag -> Bool
(PackageFlag -> PackageFlag -> Bool)
-> (PackageFlag -> PackageFlag -> Bool) -> Eq PackageFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackageFlag -> PackageFlag -> Bool
== :: PackageFlag -> PackageFlag -> Bool
$c/= :: PackageFlag -> PackageFlag -> Bool
/= :: PackageFlag -> PackageFlag -> Bool
Eq)
data PackageDBFlag
= PackageDB PkgDbRef
| NoUserPackageDB
| NoGlobalPackageDB
| ClearPackageDBs
deriving (PackageDBFlag -> PackageDBFlag -> Bool
(PackageDBFlag -> PackageDBFlag -> Bool)
-> (PackageDBFlag -> PackageDBFlag -> Bool) -> Eq PackageDBFlag
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: PackageDBFlag -> PackageDBFlag -> Bool
== :: PackageDBFlag -> PackageDBFlag -> Bool
$c/= :: PackageDBFlag -> PackageDBFlag -> Bool
/= :: PackageDBFlag -> PackageDBFlag -> Bool
Eq)
packageFlagsChanged :: DynFlags -> DynFlags -> Bool
packageFlagsChanged :: DynFlags -> DynFlags -> Bool
packageFlagsChanged DynFlags
idflags1 DynFlags
idflags0 =
DynFlags -> [PackageFlag]
packageFlags DynFlags
idflags1 [PackageFlag] -> [PackageFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageFlag]
packageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
idflags1 [IgnorePackageFlag] -> [IgnorePackageFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
idflags1 [PackageFlag] -> [PackageFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
DynFlags -> [TrustFlag]
trustFlags DynFlags
idflags1 [TrustFlag] -> [TrustFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [TrustFlag]
trustFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
idflags1 [PackageDBFlag] -> [PackageDBFlag] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
DynFlags -> [Bool]
packageGFlags DynFlags
idflags1 [Bool] -> [Bool] -> Bool
forall a. Eq a => a -> a -> Bool
/= DynFlags -> [Bool]
packageGFlags DynFlags
idflags0
where
packageGFlags :: DynFlags -> [Bool]
packageGFlags DynFlags
dflags = (GeneralFlag -> Bool) -> [GeneralFlag] -> [Bool]
forall a b. (a -> b) -> [a] -> [b]
map (GeneralFlag -> DynFlags -> Bool
`gopt` DynFlags
dflags)
[ GeneralFlag
Opt_HideAllPackages
, GeneralFlag
Opt_HideAllPluginPackages
, GeneralFlag
Opt_AutoLinkPackages ]
instance Outputable PackageFlag where
ppr :: PackageFlag -> SDoc
ppr (ExposePackage [Char]
n PackageArg
arg ModRenaming
rn) = [Char] -> SDoc
text [Char]
n SDoc -> SDoc -> SDoc
<> SDoc -> SDoc
braces (PackageArg -> SDoc
forall a. Outputable a => a -> SDoc
ppr PackageArg
arg SDoc -> SDoc -> SDoc
<+> ModRenaming -> SDoc
forall a. Outputable a => a -> SDoc
ppr ModRenaming
rn)
ppr (HidePackage [Char]
str) = [Char] -> SDoc
text [Char]
"-hide-package" SDoc -> SDoc -> SDoc
<+> [Char] -> SDoc
text [Char]
str
data DynLibLoader
= Deployable
| SystemDependent
deriving DynLibLoader -> DynLibLoader -> Bool
(DynLibLoader -> DynLibLoader -> Bool)
-> (DynLibLoader -> DynLibLoader -> Bool) -> Eq DynLibLoader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DynLibLoader -> DynLibLoader -> Bool
== :: DynLibLoader -> DynLibLoader -> Bool
$c/= :: DynLibLoader -> DynLibLoader -> Bool
/= :: DynLibLoader -> DynLibLoader -> Bool
Eq
data RtsOptsEnabled
= RtsOptsNone | RtsOptsIgnore | RtsOptsIgnoreAll | RtsOptsSafeOnly
| RtsOptsAll
deriving (Int -> RtsOptsEnabled -> ShowS
[RtsOptsEnabled] -> ShowS
RtsOptsEnabled -> [Char]
(Int -> RtsOptsEnabled -> ShowS)
-> (RtsOptsEnabled -> [Char])
-> ([RtsOptsEnabled] -> ShowS)
-> Show RtsOptsEnabled
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RtsOptsEnabled -> ShowS
showsPrec :: Int -> RtsOptsEnabled -> ShowS
$cshow :: RtsOptsEnabled -> [Char]
show :: RtsOptsEnabled -> [Char]
$cshowList :: [RtsOptsEnabled] -> ShowS
showList :: [RtsOptsEnabled] -> ShowS
Show)
positionIndependent :: DynFlags -> Bool
positionIndependent :: DynFlags -> Bool
positionIndependent DynFlags
dflags = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags Bool -> Bool -> Bool
|| GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIE DynFlags
dflags
data DynamicTooState
= DT_Dont
| DT_OK
| DT_Dyn
deriving (DynamicTooState -> DynamicTooState -> Bool
(DynamicTooState -> DynamicTooState -> Bool)
-> (DynamicTooState -> DynamicTooState -> Bool)
-> Eq DynamicTooState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DynamicTooState -> DynamicTooState -> Bool
== :: DynamicTooState -> DynamicTooState -> Bool
$c/= :: DynamicTooState -> DynamicTooState -> Bool
/= :: DynamicTooState -> DynamicTooState -> Bool
Eq,Int -> DynamicTooState -> ShowS
[DynamicTooState] -> ShowS
DynamicTooState -> [Char]
(Int -> DynamicTooState -> ShowS)
-> (DynamicTooState -> [Char])
-> ([DynamicTooState] -> ShowS)
-> Show DynamicTooState
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DynamicTooState -> ShowS
showsPrec :: Int -> DynamicTooState -> ShowS
$cshow :: DynamicTooState -> [Char]
show :: DynamicTooState -> [Char]
$cshowList :: [DynamicTooState] -> ShowS
showList :: [DynamicTooState] -> ShowS
Show,Eq DynamicTooState
Eq DynamicTooState
-> (DynamicTooState -> DynamicTooState -> Ordering)
-> (DynamicTooState -> DynamicTooState -> Bool)
-> (DynamicTooState -> DynamicTooState -> Bool)
-> (DynamicTooState -> DynamicTooState -> Bool)
-> (DynamicTooState -> DynamicTooState -> Bool)
-> (DynamicTooState -> DynamicTooState -> DynamicTooState)
-> (DynamicTooState -> DynamicTooState -> DynamicTooState)
-> Ord DynamicTooState
DynamicTooState -> DynamicTooState -> Bool
DynamicTooState -> DynamicTooState -> Ordering
DynamicTooState -> DynamicTooState -> DynamicTooState
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: DynamicTooState -> DynamicTooState -> Ordering
compare :: DynamicTooState -> DynamicTooState -> Ordering
$c< :: DynamicTooState -> DynamicTooState -> Bool
< :: DynamicTooState -> DynamicTooState -> Bool
$c<= :: DynamicTooState -> DynamicTooState -> Bool
<= :: DynamicTooState -> DynamicTooState -> Bool
$c> :: DynamicTooState -> DynamicTooState -> Bool
> :: DynamicTooState -> DynamicTooState -> Bool
$c>= :: DynamicTooState -> DynamicTooState -> Bool
>= :: DynamicTooState -> DynamicTooState -> Bool
$cmax :: DynamicTooState -> DynamicTooState -> DynamicTooState
max :: DynamicTooState -> DynamicTooState -> DynamicTooState
$cmin :: DynamicTooState -> DynamicTooState -> DynamicTooState
min :: DynamicTooState -> DynamicTooState -> DynamicTooState
Ord)
dynamicTooState :: DynFlags -> DynamicTooState
dynamicTooState :: DynFlags -> DynamicTooState
dynamicTooState DynFlags
dflags
| Bool -> Bool
not (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_BuildDynamicToo DynFlags
dflags) = DynamicTooState
DT_Dont
| DynFlags -> Bool
dynamicNow DynFlags
dflags = DynamicTooState
DT_Dyn
| Bool
otherwise = DynamicTooState
DT_OK
setDynamicNow :: DynFlags -> DynFlags
setDynamicNow :: DynFlags -> DynFlags
setDynamicNow DynFlags
dflags0 =
DynFlags
dflags0
{ dynamicNow :: Bool
dynamicNow = Bool
True
}
initDynFlags :: DynFlags -> IO DynFlags
initDynFlags :: DynFlags -> IO DynFlags
initDynFlags DynFlags
dflags = do
let
IORef (Maybe LinkerInfo)
refRtldInfo <- Maybe LinkerInfo -> IO (IORef (Maybe LinkerInfo))
forall a. a -> IO (IORef a)
newIORef Maybe LinkerInfo
forall a. Maybe a
Nothing
IORef (Maybe CompilerInfo)
refRtccInfo <- Maybe CompilerInfo -> IO (IORef (Maybe CompilerInfo))
forall a. a -> IO (IORef a)
newIORef Maybe CompilerInfo
forall a. Maybe a
Nothing
IORef (Maybe CompilerInfo)
refRtasmInfo <- Maybe CompilerInfo -> IO (IORef (Maybe CompilerInfo))
forall a. a -> IO (IORef a)
newIORef Maybe CompilerInfo
forall a. Maybe a
Nothing
Bool
canUseUnicode <- do let enc :: TextEncoding
enc = TextEncoding
localeEncoding
str :: [Char]
str = [Char]
"‘’"
(TextEncoding -> [Char] -> (CString -> IO Bool) -> IO Bool
forall a. TextEncoding -> [Char] -> (CString -> IO a) -> IO a
withCString TextEncoding
enc [Char]
str ((CString -> IO Bool) -> IO Bool)
-> (CString -> IO Bool) -> IO Bool
forall a b. (a -> b) -> a -> b
$ \CString
cstr ->
do [Char]
str' <- TextEncoding -> CString -> IO [Char]
peekCString TextEncoding
enc CString
cstr
Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ([Char]
str [Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
== [Char]
str'))
IO Bool -> (IOError -> IO Bool) -> IO Bool
forall a. IO a -> (IOError -> IO a) -> IO a
`catchIOError` \IOError
_ -> Bool -> IO Bool
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
False
Maybe [Char]
ghcNoUnicodeEnv <- [Char] -> IO (Maybe [Char])
lookupEnv [Char]
"GHC_NO_UNICODE"
let useUnicode' :: Bool
useUnicode' = Maybe [Char] -> Bool
forall a. Maybe a -> Bool
isNothing Maybe [Char]
ghcNoUnicodeEnv Bool -> Bool -> Bool
&& Bool
canUseUnicode
Maybe [Char]
maybeGhcColorsEnv <- [Char] -> IO (Maybe [Char])
lookupEnv [Char]
"GHC_COLORS"
Maybe [Char]
maybeGhcColoursEnv <- [Char] -> IO (Maybe [Char])
lookupEnv [Char]
"GHC_COLOURS"
let adjustCols :: Maybe [Char]
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols (Just [Char]
env) = [Char] -> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
Col.parseScheme [Char]
env
adjustCols Maybe [Char]
Nothing = (OverridingBool, Scheme) -> (OverridingBool, Scheme)
forall a. a -> a
id
let (OverridingBool
useColor', Scheme
colScheme') =
(Maybe [Char]
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols Maybe [Char]
maybeGhcColoursEnv ((OverridingBool, Scheme) -> (OverridingBool, Scheme))
-> ((OverridingBool, Scheme) -> (OverridingBool, Scheme))
-> (OverridingBool, Scheme)
-> (OverridingBool, Scheme)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Maybe [Char]
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols Maybe [Char]
maybeGhcColorsEnv)
(DynFlags -> OverridingBool
useColor DynFlags
dflags, DynFlags -> Scheme
colScheme DynFlags
dflags)
[Char]
tmp_dir <- ShowS
normalise ShowS -> IO [Char] -> IO [Char]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO [Char]
getTemporaryDirectory
DynFlags -> IO DynFlags
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags{
useUnicode :: Bool
useUnicode = Bool
useUnicode',
useColor :: OverridingBool
useColor = OverridingBool
useColor',
canUseColor :: Bool
canUseColor = Bool
stderrSupportsAnsiColors,
colScheme :: Scheme
colScheme = Scheme
colScheme',
rtldInfo :: IORef (Maybe LinkerInfo)
rtldInfo = IORef (Maybe LinkerInfo)
refRtldInfo,
rtccInfo :: IORef (Maybe CompilerInfo)
rtccInfo = IORef (Maybe CompilerInfo)
refRtccInfo,
rtasmInfo :: IORef (Maybe CompilerInfo)
rtasmInfo = IORef (Maybe CompilerInfo)
refRtasmInfo,
tmpDir :: TempDir
tmpDir = [Char] -> TempDir
TempDir [Char]
tmp_dir
}
defaultDynFlags :: Settings -> LlvmConfig -> DynFlags
defaultDynFlags :: Settings -> LlvmConfig -> DynFlags
defaultDynFlags Settings
mySettings LlvmConfig
llvmConfig =
DynFlags {
ghcMode :: GhcMode
ghcMode = GhcMode
CompManager,
ghcLink :: GhcLink
ghcLink = GhcLink
LinkBinary,
backend :: Backend
backend = Platform -> Backend
platformDefaultBackend (Settings -> Platform
sTargetPlatform Settings
mySettings),
verbosity :: Int
verbosity = Int
0,
debugLevel :: Int
debugLevel = Int
0,
simplPhases :: Int
simplPhases = Int
2,
maxSimplIterations :: Int
maxSimplIterations = Int
4,
ruleCheck :: Maybe [Char]
ruleCheck = Maybe [Char]
forall a. Maybe a
Nothing,
binBlobThreshold :: Maybe Word
binBlobThreshold = Word -> Maybe Word
forall a. a -> Maybe a
Just Word
500000,
maxRelevantBinds :: Maybe Int
maxRelevantBinds = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6,
maxValidHoleFits :: Maybe Int
maxValidHoleFits = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6,
maxRefHoleFits :: Maybe Int
maxRefHoleFits = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
6,
refLevelHoleFits :: Maybe Int
refLevelHoleFits = Maybe Int
forall a. Maybe a
Nothing,
maxUncoveredPatterns :: Int
maxUncoveredPatterns = Int
4,
maxPmCheckModels :: Int
maxPmCheckModels = Int
30,
simplTickFactor :: Int
simplTickFactor = Int
100,
dmdUnboxWidth :: Int
dmdUnboxWidth = Int
3,
specConstrThreshold :: Maybe Int
specConstrThreshold = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2000,
specConstrCount :: Maybe Int
specConstrCount = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
3,
specConstrRecursive :: Int
specConstrRecursive = Int
3,
liberateCaseThreshold :: Maybe Int
liberateCaseThreshold = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2000,
floatLamArgs :: Maybe Int
floatLamArgs = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
0,
liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5,
liftLamsNonRecArgs :: Maybe Int
liftLamsNonRecArgs = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
5,
liftLamsKnown :: Bool
liftLamsKnown = Bool
False,
cmmProcAlignment :: Maybe Int
cmmProcAlignment = Maybe Int
forall a. Maybe a
Nothing,
historySize :: Int
historySize = Int
20,
strictnessBefore :: [Int]
strictnessBefore = [],
parMakeCount :: Maybe Int
parMakeCount = Int -> Maybe Int
forall a. a -> Maybe a
Just Int
1,
enableTimeStats :: Bool
enableTimeStats = Bool
False,
ghcHeapSize :: Maybe Int
ghcHeapSize = Maybe Int
forall a. Maybe a
Nothing,
importPaths :: [[Char]]
importPaths = [[Char]
"."],
mainModuleNameIs :: ModuleName
mainModuleNameIs = ModuleName
mAIN_NAME,
mainFunIs :: Maybe [Char]
mainFunIs = Maybe [Char]
forall a. Maybe a
Nothing,
reductionDepth :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
mAX_REDUCTION_DEPTH,
solverIterations :: IntWithInf
solverIterations = Int -> IntWithInf
treatZeroAsInf Int
mAX_SOLVER_ITERATIONS,
homeUnitId_ :: UnitId
homeUnitId_ = UnitId
mainUnitId,
homeUnitInstanceOf_ :: Maybe UnitId
homeUnitInstanceOf_ = Maybe UnitId
forall a. Maybe a
Nothing,
homeUnitInstantiations_ :: [(ModuleName, Module)]
homeUnitInstantiations_ = [],
workingDirectory :: Maybe [Char]
workingDirectory = Maybe [Char]
forall a. Maybe a
Nothing,
thisPackageName :: Maybe [Char]
thisPackageName = Maybe [Char]
forall a. Maybe a
Nothing,
hiddenModules :: Set ModuleName
hiddenModules = Set ModuleName
forall a. Set a
Set.empty,
reexportedModules :: Set ModuleName
reexportedModules = Set ModuleName
forall a. Set a
Set.empty,
objectDir :: Maybe [Char]
objectDir = Maybe [Char]
forall a. Maybe a
Nothing,
dylibInstallName :: Maybe [Char]
dylibInstallName = Maybe [Char]
forall a. Maybe a
Nothing,
hiDir :: Maybe [Char]
hiDir = Maybe [Char]
forall a. Maybe a
Nothing,
hieDir :: Maybe [Char]
hieDir = Maybe [Char]
forall a. Maybe a
Nothing,
stubDir :: Maybe [Char]
stubDir = Maybe [Char]
forall a. Maybe a
Nothing,
dumpDir :: Maybe [Char]
dumpDir = Maybe [Char]
forall a. Maybe a
Nothing,
objectSuf_ :: [Char]
objectSuf_ = Phase -> [Char]
phaseInputExt Phase
StopLn,
hcSuf :: [Char]
hcSuf = Phase -> [Char]
phaseInputExt Phase
HCc,
hiSuf_ :: [Char]
hiSuf_ = [Char]
"hi",
hieSuf :: [Char]
hieSuf = [Char]
"hie",
dynObjectSuf_ :: [Char]
dynObjectSuf_ = [Char]
"dyn_" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ Phase -> [Char]
phaseInputExt Phase
StopLn,
dynHiSuf_ :: [Char]
dynHiSuf_ = [Char]
"dyn_hi",
dynamicNow :: Bool
dynamicNow = Bool
False,
pluginModNames :: [ModuleName]
pluginModNames = [],
pluginModNameOpts :: [(ModuleName, [Char])]
pluginModNameOpts = [],
frontendPluginOpts :: [[Char]]
frontendPluginOpts = [],
outputFile_ :: Maybe [Char]
outputFile_ = Maybe [Char]
forall a. Maybe a
Nothing,
dynOutputFile_ :: Maybe [Char]
dynOutputFile_ = Maybe [Char]
forall a. Maybe a
Nothing,
outputHi :: Maybe [Char]
outputHi = Maybe [Char]
forall a. Maybe a
Nothing,
dynOutputHi :: Maybe [Char]
dynOutputHi = Maybe [Char]
forall a. Maybe a
Nothing,
dynLibLoader :: DynLibLoader
dynLibLoader = DynLibLoader
SystemDependent,
dumpPrefix :: [Char]
dumpPrefix = [Char]
"non-module.",
dumpPrefixForce :: Maybe [Char]
dumpPrefixForce = Maybe [Char]
forall a. Maybe a
Nothing,
ldInputs :: [Option]
ldInputs = [],
includePaths :: IncludeSpecs
includePaths = [[Char]] -> [[Char]] -> [[Char]] -> IncludeSpecs
IncludeSpecs [] [] [],
libraryPaths :: [[Char]]
libraryPaths = [],
frameworkPaths :: [[Char]]
frameworkPaths = [],
cmdlineFrameworks :: [[Char]]
cmdlineFrameworks = [],
rtsOpts :: Maybe [Char]
rtsOpts = Maybe [Char]
forall a. Maybe a
Nothing,
rtsOptsEnabled :: RtsOptsEnabled
rtsOptsEnabled = RtsOptsEnabled
RtsOptsSafeOnly,
rtsOptsSuggestions :: Bool
rtsOptsSuggestions = Bool
True,
hpcDir :: [Char]
hpcDir = [Char]
".hpc",
packageDBFlags :: [PackageDBFlag]
packageDBFlags = [],
packageFlags :: [PackageFlag]
packageFlags = [],
pluginPackageFlags :: [PackageFlag]
pluginPackageFlags = [],
ignorePackageFlags :: [IgnorePackageFlag]
ignorePackageFlags = [],
trustFlags :: [TrustFlag]
trustFlags = [],
packageEnv :: Maybe [Char]
packageEnv = Maybe [Char]
forall a. Maybe a
Nothing,
targetWays_ :: Ways
targetWays_ = Ways
forall a. Set a
Set.empty,
splitInfo :: Maybe ([Char], Int)
splitInfo = Maybe ([Char], Int)
forall a. Maybe a
Nothing,
ghcNameVersion :: GhcNameVersion
ghcNameVersion = Settings -> GhcNameVersion
sGhcNameVersion Settings
mySettings,
fileSettings :: FileSettings
fileSettings = Settings -> FileSettings
sFileSettings Settings
mySettings,
toolSettings :: ToolSettings
toolSettings = Settings -> ToolSettings
sToolSettings Settings
mySettings,
targetPlatform :: Platform
targetPlatform = Settings -> Platform
sTargetPlatform Settings
mySettings,
platformMisc :: PlatformMisc
platformMisc = Settings -> PlatformMisc
sPlatformMisc Settings
mySettings,
rawSettings :: [([Char], [Char])]
rawSettings = Settings -> [([Char], [Char])]
sRawSettings Settings
mySettings,
tmpDir :: TempDir
tmpDir = [Char] -> TempDir
forall a. [Char] -> a
panic [Char]
"defaultDynFlags: uninitialized tmpDir",
llvmConfig :: LlvmConfig
llvmConfig = LlvmConfig
llvmConfig,
llvmOptLevel :: Int
llvmOptLevel = Int
0,
depMakefile :: [Char]
depMakefile = [Char]
"Makefile",
depIncludePkgDeps :: Bool
depIncludePkgDeps = Bool
False,
depIncludeCppDeps :: Bool
depIncludeCppDeps = Bool
False,
depExcludeMods :: [ModuleName]
depExcludeMods = [],
depSuffixes :: [[Char]]
depSuffixes = [],
ghcVersionFile :: Maybe [Char]
ghcVersionFile = Maybe [Char]
forall a. Maybe a
Nothing,
haddockOptions :: Maybe [Char]
haddockOptions = Maybe [Char]
forall a. Maybe a
Nothing,
dumpFlags :: EnumSet DumpFlag
dumpFlags = EnumSet DumpFlag
forall a. EnumSet a
EnumSet.empty,
generalFlags :: EnumSet GeneralFlag
generalFlags = [GeneralFlag] -> EnumSet GeneralFlag
forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList (Settings -> [GeneralFlag]
defaultFlags Settings
mySettings),
warningFlags :: EnumSet WarningFlag
warningFlags = [WarningFlag] -> EnumSet WarningFlag
forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList [WarningFlag]
standardWarnings,
fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = EnumSet WarningFlag
forall a. EnumSet a
EnumSet.empty,
ghciScripts :: [[Char]]
ghciScripts = [],
language :: Maybe Language
language = Maybe Language
forall a. Maybe a
Nothing,
safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
Sf_None,
safeInfer :: Bool
safeInfer = Bool
True,
safeInferred :: Bool
safeInferred = Bool
True,
thOnLoc :: SrcSpan
thOnLoc = SrcSpan
noSrcSpan,
newDerivOnLoc :: SrcSpan
newDerivOnLoc = SrcSpan
noSrcSpan,
deriveViaOnLoc :: SrcSpan
deriveViaOnLoc = SrcSpan
noSrcSpan,
overlapInstLoc :: SrcSpan
overlapInstLoc = SrcSpan
noSrcSpan,
incoherentOnLoc :: SrcSpan
incoherentOnLoc = SrcSpan
noSrcSpan,
pkgTrustOnLoc :: SrcSpan
pkgTrustOnLoc = SrcSpan
noSrcSpan,
warnSafeOnLoc :: SrcSpan
warnSafeOnLoc = SrcSpan
noSrcSpan,
warnUnsafeOnLoc :: SrcSpan
warnUnsafeOnLoc = SrcSpan
noSrcSpan,
trustworthyOnLoc :: SrcSpan
trustworthyOnLoc = SrcSpan
noSrcSpan,
extensions :: [OnOff Extension]
extensions = [],
extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags Maybe Language
forall a. Maybe a
Nothing [],
unfoldingOpts :: UnfoldingOpts
unfoldingOpts = UnfoldingOpts
defaultUnfoldingOpts,
maxWorkerArgs :: Int
maxWorkerArgs = Int
10,
ghciHistSize :: Int
ghciHistSize = Int
50,
flushOut :: FlushOut
flushOut = FlushOut
defaultFlushOut,
pprUserLength :: Int
pprUserLength = Int
5,
pprCols :: Int
pprCols = Int
100,
useUnicode :: Bool
useUnicode = Bool
False,
useColor :: OverridingBool
useColor = OverridingBool
Auto,
canUseColor :: Bool
canUseColor = Bool
False,
colScheme :: Scheme
colScheme = Scheme
Col.defaultScheme,
profAuto :: ProfAuto
profAuto = ProfAuto
NoProfAuto,
callerCcFilters :: [CallerCcFilter]
callerCcFilters = [],
interactivePrint :: Maybe [Char]
interactivePrint = Maybe [Char]
forall a. Maybe a
Nothing,
sseVersion :: Maybe SseVersion
sseVersion = Maybe SseVersion
forall a. Maybe a
Nothing,
bmiVersion :: Maybe BmiVersion
bmiVersion = Maybe BmiVersion
forall a. Maybe a
Nothing,
avx :: Bool
avx = Bool
False,
avx2 :: Bool
avx2 = Bool
False,
avx512cd :: Bool
avx512cd = Bool
False,
avx512er :: Bool
avx512er = Bool
False,
avx512f :: Bool
avx512f = Bool
False,
avx512pf :: Bool
avx512pf = Bool
False,
rtldInfo :: IORef (Maybe LinkerInfo)
rtldInfo = [Char] -> IORef (Maybe LinkerInfo)
forall a. [Char] -> a
panic [Char]
"defaultDynFlags: no rtldInfo",
rtccInfo :: IORef (Maybe CompilerInfo)
rtccInfo = [Char] -> IORef (Maybe CompilerInfo)
forall a. [Char] -> a
panic [Char]
"defaultDynFlags: no rtccInfo",
rtasmInfo :: IORef (Maybe CompilerInfo)
rtasmInfo = [Char] -> IORef (Maybe CompilerInfo)
forall a. [Char] -> a
panic [Char]
"defaultDynFlags: no rtasmInfo",
maxInlineAllocSize :: Int
maxInlineAllocSize = Int
128,
maxInlineMemcpyInsns :: Int
maxInlineMemcpyInsns = Int
32,
maxInlineMemsetInsns :: Int
maxInlineMemsetInsns = Int
32,
initialUnique :: Word
initialUnique = Word
0,
uniqueIncrement :: Int
uniqueIncrement = Int
1,
reverseErrors :: Bool
reverseErrors = Bool
False,
maxErrors :: Maybe Int
maxErrors = Maybe Int
forall a. Maybe a
Nothing,
cfgWeights :: Weights
cfgWeights = Weights
defaultWeights
}
type FatalMessager = String -> IO ()
defaultFatalMessager :: FatalMessager
defaultFatalMessager :: FatalMessager
defaultFatalMessager = Handle -> FatalMessager
hPutStrLn Handle
stderr
newtype FlushOut = FlushOut (IO ())
defaultFlushOut :: FlushOut
defaultFlushOut :: FlushOut
defaultFlushOut = IO () -> FlushOut
FlushOut (IO () -> FlushOut) -> IO () -> FlushOut
forall a b. (a -> b) -> a -> b
$ Handle -> IO ()
hFlush Handle
stdout
data OnOff a = On a
| Off a
deriving (OnOff a -> OnOff a -> Bool
(OnOff a -> OnOff a -> Bool)
-> (OnOff a -> OnOff a -> Bool) -> Eq (OnOff a)
forall a. Eq a => OnOff a -> OnOff a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => OnOff a -> OnOff a -> Bool
== :: OnOff a -> OnOff a -> Bool
$c/= :: forall a. Eq a => OnOff a -> OnOff a -> Bool
/= :: OnOff a -> OnOff a -> Bool
Eq, Int -> OnOff a -> ShowS
[OnOff a] -> ShowS
OnOff a -> [Char]
(Int -> OnOff a -> ShowS)
-> (OnOff a -> [Char]) -> ([OnOff a] -> ShowS) -> Show (OnOff a)
forall a. Show a => Int -> OnOff a -> ShowS
forall a. Show a => [OnOff a] -> ShowS
forall a. Show a => OnOff a -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> OnOff a -> ShowS
showsPrec :: Int -> OnOff a -> ShowS
$cshow :: forall a. Show a => OnOff a -> [Char]
show :: OnOff a -> [Char]
$cshowList :: forall a. Show a => [OnOff a] -> ShowS
showList :: [OnOff a] -> ShowS
Show)
instance Outputable a => Outputable (OnOff a) where
ppr :: OnOff a -> SDoc
ppr (On a
x) = [Char] -> SDoc
text [Char]
"On" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
x
ppr (Off a
x) = [Char] -> SDoc
text [Char]
"Off" SDoc -> SDoc -> SDoc
<+> a -> SDoc
forall a. Outputable a => a -> SDoc
ppr a
x
flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> EnumSet LangExt.Extension
flattenExtensionFlags :: Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags Maybe Language
ml = (OnOff Extension -> EnumSet Extension -> EnumSet Extension)
-> EnumSet Extension -> [OnOff Extension] -> EnumSet Extension
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr OnOff Extension -> EnumSet Extension -> EnumSet Extension
forall {a}. Enum a => OnOff a -> EnumSet a -> EnumSet a
f EnumSet Extension
defaultExtensionFlags
where f :: OnOff a -> EnumSet a -> EnumSet a
f (On a
f) EnumSet a
flags = a -> EnumSet a -> EnumSet a
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert a
f EnumSet a
flags
f (Off a
f) EnumSet a
flags = a -> EnumSet a -> EnumSet a
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete a
f EnumSet a
flags
defaultExtensionFlags :: EnumSet Extension
defaultExtensionFlags = [Extension] -> EnumSet Extension
forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList (Maybe Language -> [Extension]
languageExtensions Maybe Language
ml)
languageExtensions :: Maybe Language -> [LangExt.Extension]
languageExtensions :: Maybe Language -> [Extension]
languageExtensions Maybe Language
Nothing = Maybe Language -> [Extension]
languageExtensions (Language -> Maybe Language
forall a. a -> Maybe a
Just Language
GHC2021)
languageExtensions (Just Language
Haskell98)
= [Extension
LangExt.ImplicitPrelude,
Extension
LangExt.StarIsType,
Extension
LangExt.CUSKs,
Extension
LangExt.MonomorphismRestriction,
Extension
LangExt.NPlusKPatterns,
Extension
LangExt.DatatypeContexts,
Extension
LangExt.TraditionalRecordSyntax,
Extension
LangExt.FieldSelectors,
Extension
LangExt.NondecreasingIndentation,
Extension
LangExt.DeepSubsumption
]
languageExtensions (Just Language
Haskell2010)
= [Extension
LangExt.ImplicitPrelude,
Extension
LangExt.StarIsType,
Extension
LangExt.CUSKs,
Extension
LangExt.MonomorphismRestriction,
Extension
LangExt.DatatypeContexts,
Extension
LangExt.TraditionalRecordSyntax,
Extension
LangExt.EmptyDataDecls,
Extension
LangExt.ForeignFunctionInterface,
Extension
LangExt.PatternGuards,
Extension
LangExt.DoAndIfThenElse,
Extension
LangExt.FieldSelectors,
Extension
LangExt.RelaxedPolyRec,
Extension
LangExt.DeepSubsumption ]
languageExtensions (Just Language
GHC2021)
= [Extension
LangExt.ImplicitPrelude,
Extension
LangExt.StarIsType,
Extension
LangExt.MonomorphismRestriction,
Extension
LangExt.TraditionalRecordSyntax,
Extension
LangExt.EmptyDataDecls,
Extension
LangExt.ForeignFunctionInterface,
Extension
LangExt.PatternGuards,
Extension
LangExt.DoAndIfThenElse,
Extension
LangExt.FieldSelectors,
Extension
LangExt.RelaxedPolyRec,
Extension
LangExt.BangPatterns,
Extension
LangExt.BinaryLiterals,
Extension
LangExt.ConstrainedClassMethods,
Extension
LangExt.ConstraintKinds,
Extension
LangExt.DeriveDataTypeable,
Extension
LangExt.DeriveFoldable,
Extension
LangExt.DeriveFunctor,
Extension
LangExt.DeriveGeneric,
Extension
LangExt.DeriveLift,
Extension
LangExt.DeriveTraversable,
Extension
LangExt.EmptyCase,
Extension
LangExt.EmptyDataDeriving,
Extension
LangExt.ExistentialQuantification,
Extension
LangExt.ExplicitForAll,
Extension
LangExt.FlexibleContexts,
Extension
LangExt.FlexibleInstances,
Extension
LangExt.GADTSyntax,
Extension
LangExt.GeneralizedNewtypeDeriving,
Extension
LangExt.HexFloatLiterals,
Extension
LangExt.ImportQualifiedPost,
Extension
LangExt.InstanceSigs,
Extension
LangExt.KindSignatures,
Extension
LangExt.MultiParamTypeClasses,
Extension
LangExt.NamedFieldPuns,
Extension
LangExt.NamedWildCards,
Extension
LangExt.NumericUnderscores,
Extension
LangExt.PolyKinds,
Extension
LangExt.PostfixOperators,
Extension
LangExt.RankNTypes,
Extension
LangExt.ScopedTypeVariables,
Extension
LangExt.StandaloneDeriving,
Extension
LangExt.StandaloneKindSignatures,
Extension
LangExt.TupleSections,
Extension
LangExt.TypeApplications,
Extension
LangExt.TypeOperators,
Extension
LangExt.TypeSynonymInstances]
hasPprDebug :: DynFlags -> Bool
hasPprDebug :: DynFlags -> Bool
hasPprDebug = DumpFlag -> DynFlags -> Bool
dopt DumpFlag
Opt_D_ppr_debug
hasNoDebugOutput :: DynFlags -> Bool
hasNoDebugOutput :: DynFlags -> Bool
hasNoDebugOutput = DumpFlag -> DynFlags -> Bool
dopt DumpFlag
Opt_D_no_debug_output
hasNoStateHack :: DynFlags -> Bool
hasNoStateHack :: DynFlags -> Bool
hasNoStateHack = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_G_NoStateHack
hasNoOptCoercion :: DynFlags -> Bool
hasNoOptCoercion :: DynFlags -> Bool
hasNoOptCoercion = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_G_NoOptCoercion
dopt :: DumpFlag -> DynFlags -> Bool
dopt :: DumpFlag -> DynFlags -> Bool
dopt DumpFlag
f DynFlags
dflags = (DumpFlag
f DumpFlag -> EnumSet DumpFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet DumpFlag
dumpFlags DynFlags
dflags)
Bool -> Bool -> Bool
|| (DynFlags -> Int
verbosity DynFlags
dflags Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
4 Bool -> Bool -> Bool
&& DumpFlag -> Bool
enableIfVerbose DumpFlag
f)
where enableIfVerbose :: DumpFlag -> Bool
enableIfVerbose DumpFlag
Opt_D_dump_tc_trace = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_rn_trace = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_cs_trace = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_if_trace = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_tc = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_rn = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_rn_stats = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_hi_diffs = Bool
False
enableIfVerbose DumpFlag
Opt_D_verbose_core2core = Bool
False
enableIfVerbose DumpFlag
Opt_D_verbose_stg2stg = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_splices = Bool
False
enableIfVerbose DumpFlag
Opt_D_th_dec_file = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_rule_firings = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_rule_rewrites = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_simpl_trace = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_rtti = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_inlinings = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_verbose_inlinings = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_core_stats = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_asm_stats = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_types = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_simpl_iterations = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_ticked = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_view_pattern_commoning = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_mod_cycles = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_mod_map = Bool
False
enableIfVerbose DumpFlag
Opt_D_dump_ec_trace = Bool
False
enableIfVerbose DumpFlag
_ = Bool
True
dopt_set :: DynFlags -> DumpFlag -> DynFlags
dopt_set :: DynFlags -> DumpFlag -> DynFlags
dopt_set DynFlags
dfs DumpFlag
f = DynFlags
dfs{ dumpFlags :: EnumSet DumpFlag
dumpFlags = DumpFlag -> EnumSet DumpFlag -> EnumSet DumpFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert DumpFlag
f (DynFlags -> EnumSet DumpFlag
dumpFlags DynFlags
dfs) }
dopt_unset :: DynFlags -> DumpFlag -> DynFlags
dopt_unset :: DynFlags -> DumpFlag -> DynFlags
dopt_unset DynFlags
dfs DumpFlag
f = DynFlags
dfs{ dumpFlags :: EnumSet DumpFlag
dumpFlags = DumpFlag -> EnumSet DumpFlag -> EnumSet DumpFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete DumpFlag
f (DynFlags -> EnumSet DumpFlag
dumpFlags DynFlags
dfs) }
gopt :: GeneralFlag -> DynFlags -> Bool
gopt :: GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags
| DynFlags -> Bool
dynamicNow DynFlags
dflags = Bool
True
gopt GeneralFlag
Opt_ExternalDynamicRefs DynFlags
dflags
| DynFlags -> Bool
dynamicNow DynFlags
dflags = Bool
True
gopt GeneralFlag
Opt_SplitSections DynFlags
dflags
| DynFlags -> Bool
dynamicNow DynFlags
dflags = Bool
False
gopt GeneralFlag
f DynFlags
dflags = GeneralFlag
f GeneralFlag -> EnumSet GeneralFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dflags
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dfs GeneralFlag
f = DynFlags
dfs{ generalFlags :: EnumSet GeneralFlag
generalFlags = GeneralFlag -> EnumSet GeneralFlag -> EnumSet GeneralFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert GeneralFlag
f (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dfs) }
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dfs GeneralFlag
f = DynFlags
dfs{ generalFlags :: EnumSet GeneralFlag
generalFlags = GeneralFlag -> EnumSet GeneralFlag -> EnumSet GeneralFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete GeneralFlag
f (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dfs) }
wopt :: WarningFlag -> DynFlags -> Bool
wopt :: WarningFlag -> DynFlags -> Bool
wopt WarningFlag
f DynFlags
dflags = WarningFlag
f WarningFlag -> EnumSet WarningFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet WarningFlag
warningFlags DynFlags
dflags
wopt_set :: DynFlags -> WarningFlag -> DynFlags
wopt_set :: DynFlags -> WarningFlag -> DynFlags
wopt_set DynFlags
dfs WarningFlag
f = DynFlags
dfs{ warningFlags :: EnumSet WarningFlag
warningFlags = WarningFlag -> EnumSet WarningFlag -> EnumSet WarningFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert WarningFlag
f (DynFlags -> EnumSet WarningFlag
warningFlags DynFlags
dfs) }
wopt_unset :: DynFlags -> WarningFlag -> DynFlags
wopt_unset :: DynFlags -> WarningFlag -> DynFlags
wopt_unset DynFlags
dfs WarningFlag
f = DynFlags
dfs{ warningFlags :: EnumSet WarningFlag
warningFlags = WarningFlag -> EnumSet WarningFlag -> EnumSet WarningFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete WarningFlag
f (DynFlags -> EnumSet WarningFlag
warningFlags DynFlags
dfs) }
wopt_fatal :: WarningFlag -> DynFlags -> Bool
wopt_fatal :: WarningFlag -> DynFlags -> Bool
wopt_fatal WarningFlag
f DynFlags
dflags = WarningFlag
f WarningFlag -> EnumSet WarningFlag -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dflags
wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_set_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_set_fatal DynFlags
dfs WarningFlag
f
= DynFlags
dfs { fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = WarningFlag -> EnumSet WarningFlag -> EnumSet WarningFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert WarningFlag
f (DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dfs) }
wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_unset_fatal :: DynFlags -> WarningFlag -> DynFlags
wopt_unset_fatal DynFlags
dfs WarningFlag
f
= DynFlags
dfs { fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = WarningFlag -> EnumSet WarningFlag -> EnumSet WarningFlag
forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete WarningFlag
f (DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dfs) }
xopt :: LangExt.Extension -> DynFlags -> Bool
xopt :: Extension -> DynFlags -> Bool
xopt Extension
f DynFlags
dflags = Extension
f Extension -> EnumSet Extension -> Bool
forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet Extension
extensionFlags DynFlags
dflags
xopt_set :: DynFlags -> LangExt.Extension -> DynFlags
xopt_set :: DynFlags -> Extension -> DynFlags
xopt_set DynFlags
dfs Extension
f
= let onoffs :: [OnOff Extension]
onoffs = Extension -> OnOff Extension
forall a. a -> OnOff a
On Extension
f OnOff Extension -> [OnOff Extension] -> [OnOff Extension]
forall a. a -> [a] -> [a]
: DynFlags -> [OnOff Extension]
extensions DynFlags
dfs
in DynFlags
dfs { extensions :: [OnOff Extension]
extensions = [OnOff Extension]
onoffs,
extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags (DynFlags -> Maybe Language
language DynFlags
dfs) [OnOff Extension]
onoffs }
xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags
xopt_unset :: DynFlags -> Extension -> DynFlags
xopt_unset DynFlags
dfs Extension
f
= let onoffs :: [OnOff Extension]
onoffs = Extension -> OnOff Extension
forall a. a -> OnOff a
Off Extension
f OnOff Extension -> [OnOff Extension] -> [OnOff Extension]
forall a. a -> [a] -> [a]
: DynFlags -> [OnOff Extension]
extensions DynFlags
dfs
in DynFlags
dfs { extensions :: [OnOff Extension]
extensions = [OnOff Extension]
onoffs,
extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags (DynFlags -> Maybe Language
language DynFlags
dfs) [OnOff Extension]
onoffs }
xopt_set_unlessExplSpec
:: LangExt.Extension
-> (DynFlags -> LangExt.Extension -> DynFlags)
-> DynFlags -> DynFlags
xopt_set_unlessExplSpec :: Extension
-> (DynFlags -> Extension -> DynFlags) -> DynFlags -> DynFlags
xopt_set_unlessExplSpec Extension
ext DynFlags -> Extension -> DynFlags
setUnset DynFlags
dflags =
let referedExts :: [Extension]
referedExts = OnOff Extension -> Extension
forall {a}. OnOff a -> a
stripOnOff (OnOff Extension -> Extension) -> [OnOff Extension] -> [Extension]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> DynFlags -> [OnOff Extension]
extensions DynFlags
dflags
stripOnOff :: OnOff a -> a
stripOnOff (On a
x) = a
x
stripOnOff (Off a
x) = a
x
in
if Extension
ext Extension -> [Extension] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Extension]
referedExts then DynFlags
dflags else DynFlags -> Extension -> DynFlags
setUnset DynFlags
dflags Extension
ext
xopt_DuplicateRecordFields :: DynFlags -> FieldLabel.DuplicateRecordFields
xopt_DuplicateRecordFields :: DynFlags -> DuplicateRecordFields
xopt_DuplicateRecordFields DynFlags
dfs
| Extension -> DynFlags -> Bool
xopt Extension
LangExt.DuplicateRecordFields DynFlags
dfs = DuplicateRecordFields
FieldLabel.DuplicateRecordFields
| Bool
otherwise = DuplicateRecordFields
FieldLabel.NoDuplicateRecordFields
xopt_FieldSelectors :: DynFlags -> FieldLabel.FieldSelectors
xopt_FieldSelectors :: DynFlags -> FieldSelectors
xopt_FieldSelectors DynFlags
dfs
| Extension -> DynFlags -> Bool
xopt Extension
LangExt.FieldSelectors DynFlags
dfs = FieldSelectors
FieldLabel.FieldSelectors
| Bool
otherwise = FieldSelectors
FieldLabel.NoFieldSelectors
lang_set :: DynFlags -> Maybe Language -> DynFlags
lang_set :: DynFlags -> Maybe Language -> DynFlags
lang_set DynFlags
dflags Maybe Language
lang =
DynFlags
dflags {
language :: Maybe Language
language = Maybe Language
lang,
extensionFlags :: EnumSet Extension
extensionFlags = Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags Maybe Language
lang (DynFlags -> [OnOff Extension]
extensions DynFlags
dflags)
}
setLanguage :: Language -> DynP ()
setLanguage :: Language -> DynP ()
setLanguage Language
l = (DynFlags -> DynFlags) -> DynP ()
upd (DynFlags -> Maybe Language -> DynFlags
`lang_set` Language -> Maybe Language
forall a. a -> Maybe a
Just Language
l)
packageTrustOn :: DynFlags -> Bool
packageTrustOn :: DynFlags -> Bool
packageTrustOn = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PackageTrust
safeHaskellOn :: DynFlags -> Bool
safeHaskellOn :: DynFlags -> Bool
safeHaskellOn DynFlags
dflags = DynFlags -> Bool
safeHaskellModeEnabled DynFlags
dflags Bool -> Bool -> Bool
|| DynFlags -> Bool
safeInferOn DynFlags
dflags
safeHaskellModeEnabled :: DynFlags -> Bool
safeHaskellModeEnabled :: DynFlags -> Bool
safeHaskellModeEnabled DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> [SafeHaskellMode] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [SafeHaskellMode
Sf_Unsafe, SafeHaskellMode
Sf_Trustworthy
, SafeHaskellMode
Sf_Safe ]
safeLanguageOn :: DynFlags -> Bool
safeLanguageOn :: DynFlags -> Bool
safeLanguageOn DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Safe
safeInferOn :: DynFlags -> Bool
safeInferOn :: DynFlags -> Bool
safeInferOn = DynFlags -> Bool
safeInfer
safeImportsOn :: DynFlags -> Bool
safeImportsOn :: DynFlags -> Bool
safeImportsOn DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Unsafe Bool -> Bool -> Bool
||
DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Trustworthy Bool -> Bool -> Bool
||
DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Safe
setSafeHaskell :: SafeHaskellMode -> DynP ()
setSafeHaskell :: SafeHaskellMode -> DynP ()
setSafeHaskell SafeHaskellMode
s = (DynFlags -> DynP DynFlags) -> DynP ()
updM DynFlags -> DynP DynFlags
f
where f :: DynFlags -> DynP DynFlags
f DynFlags
dfs = do
let sf :: SafeHaskellMode
sf = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dfs
SafeHaskellMode
safeM <- SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags SafeHaskellMode
sf SafeHaskellMode
s
case SafeHaskellMode
s of
SafeHaskellMode
Sf_Safe -> DynFlags -> DynP DynFlags
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM, safeInfer :: Bool
safeInfer = Bool
False }
SafeHaskellMode
Sf_Trustworthy -> do
SrcSpan
l <- EwM (CmdLineP DynFlags) SrcSpan
forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
DynFlags -> DynP DynFlags
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM, trustworthyOnLoc :: SrcSpan
trustworthyOnLoc = SrcSpan
l }
SafeHaskellMode
_ -> DynFlags -> DynP DynFlags
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM }
safeDirectImpsReq :: DynFlags -> Bool
safeDirectImpsReq :: DynFlags -> Bool
safeDirectImpsReq DynFlags
d = DynFlags -> Bool
safeLanguageOn DynFlags
d
safeImplicitImpsReq :: DynFlags -> Bool
safeImplicitImpsReq :: DynFlags -> Bool
safeImplicitImpsReq DynFlags
d = DynFlags -> Bool
safeLanguageOn DynFlags
d
combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags SafeHaskellMode
a SafeHaskellMode
b | SafeHaskellMode
a SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_None = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
b
| SafeHaskellMode
b SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_None = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
a
| SafeHaskellMode
a SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Ignore Bool -> Bool -> Bool
|| SafeHaskellMode
b SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Ignore = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
Sf_Ignore
| SafeHaskellMode
a SafeHaskellMode -> SafeHaskellMode -> Bool
forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
b = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
a
| Bool
otherwise = [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addErr [Char]
errm DynP () -> DynP SafeHaskellMode -> DynP SafeHaskellMode
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SafeHaskellMode
a
where errm :: [Char]
errm = [Char]
"Incompatible Safe Haskell flags! ("
[Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SafeHaskellMode -> [Char]
forall a. Show a => a -> [Char]
show SafeHaskellMode
a [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
", " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ SafeHaskellMode -> [Char]
forall a. Show a => a -> [Char]
show SafeHaskellMode
b [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
")"
unsafeFlags, unsafeFlagsForInfer
:: [(String, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
unsafeFlags :: [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
unsafeFlags = [ ([Char]
"-XGeneralizedNewtypeDeriving", DynFlags -> SrcSpan
newDerivOnLoc,
Extension -> DynFlags -> Bool
xopt Extension
LangExt.GeneralizedNewtypeDeriving,
(DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.GeneralizedNewtypeDeriving)
, ([Char]
"-XDerivingVia", DynFlags -> SrcSpan
deriveViaOnLoc,
Extension -> DynFlags -> Bool
xopt Extension
LangExt.DerivingVia,
(DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.DerivingVia)
, ([Char]
"-XTemplateHaskell", DynFlags -> SrcSpan
thOnLoc,
Extension -> DynFlags -> Bool
xopt Extension
LangExt.TemplateHaskell,
(DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.TemplateHaskell)
]
unsafeFlagsForInfer :: [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
unsafeFlagsForInfer = [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
unsafeFlags
getOpts :: DynFlags
-> (DynFlags -> [a])
-> [a]
getOpts :: forall a. DynFlags -> (DynFlags -> [a]) -> [a]
getOpts DynFlags
dflags DynFlags -> [a]
opts = [a] -> [a]
forall a. [a] -> [a]
reverse (DynFlags -> [a]
opts DynFlags
dflags)
getVerbFlags :: DynFlags -> [String]
getVerbFlags :: DynFlags -> [[Char]]
getVerbFlags DynFlags
dflags
| DynFlags -> Int
verbosity DynFlags
dflags Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
4 = [[Char]
"-v"]
| Bool
otherwise = []
setObjectDir, setHiDir, setHieDir, setStubDir, setDumpDir, setOutputDir,
setDynObjectSuf, setDynHiSuf,
setDylibInstallName,
setObjectSuf, setHiSuf, setHieSuf, setHcSuf, parseDynLibLoaderMode,
setPgmP, addOptl, addOptc, addOptcxx, addOptP,
addCmdlineFramework, addHaddockOpts, addGhciScript,
setInteractivePrint
:: String -> DynFlags -> DynFlags
setOutputFile, setDynOutputFile, setOutputHi, setDynOutputHi, setDumpPrefixForce
:: Maybe String -> DynFlags -> DynFlags
setObjectDir :: [Char] -> DynFlags -> DynFlags
setObjectDir [Char]
f DynFlags
d = DynFlags
d { objectDir :: Maybe [Char]
objectDir = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
setHiDir :: [Char] -> DynFlags -> DynFlags
setHiDir [Char]
f DynFlags
d = DynFlags
d { hiDir :: Maybe [Char]
hiDir = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
setHieDir :: [Char] -> DynFlags -> DynFlags
setHieDir [Char]
f DynFlags
d = DynFlags
d { hieDir :: Maybe [Char]
hieDir = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
setStubDir :: [Char] -> DynFlags -> DynFlags
setStubDir [Char]
f DynFlags
d = DynFlags
d { stubDir :: Maybe [Char]
stubDir = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f
, includePaths :: IncludeSpecs
includePaths = IncludeSpecs -> [[Char]] -> IncludeSpecs
addGlobalInclude (DynFlags -> IncludeSpecs
includePaths DynFlags
d) [[Char]
f] }
setDumpDir :: [Char] -> DynFlags -> DynFlags
setDumpDir [Char]
f DynFlags
d = DynFlags
d { dumpDir :: Maybe [Char]
dumpDir = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
setOutputDir :: [Char] -> DynFlags -> DynFlags
setOutputDir [Char]
f = [Char] -> DynFlags -> DynFlags
setObjectDir [Char]
f
(DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setHieDir [Char]
f
(DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setHiDir [Char]
f
(DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setStubDir [Char]
f
(DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setDumpDir [Char]
f
setDylibInstallName :: [Char] -> DynFlags -> DynFlags
setDylibInstallName [Char]
f DynFlags
d = DynFlags
d { dylibInstallName :: Maybe [Char]
dylibInstallName = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
setObjectSuf :: [Char] -> DynFlags -> DynFlags
setObjectSuf [Char]
f DynFlags
d = DynFlags
d { objectSuf_ :: [Char]
objectSuf_ = [Char]
f}
setDynObjectSuf :: [Char] -> DynFlags -> DynFlags
setDynObjectSuf [Char]
f DynFlags
d = DynFlags
d { dynObjectSuf_ :: [Char]
dynObjectSuf_ = [Char]
f}
setHiSuf :: [Char] -> DynFlags -> DynFlags
setHiSuf [Char]
f DynFlags
d = DynFlags
d { hiSuf_ :: [Char]
hiSuf_ = [Char]
f}
setHieSuf :: [Char] -> DynFlags -> DynFlags
setHieSuf [Char]
f DynFlags
d = DynFlags
d { hieSuf :: [Char]
hieSuf = [Char]
f}
setDynHiSuf :: [Char] -> DynFlags -> DynFlags
setDynHiSuf [Char]
f DynFlags
d = DynFlags
d { dynHiSuf_ :: [Char]
dynHiSuf_ = [Char]
f}
setHcSuf :: [Char] -> DynFlags -> DynFlags
setHcSuf [Char]
f DynFlags
d = DynFlags
d { hcSuf :: [Char]
hcSuf = [Char]
f}
setOutputFile :: Maybe [Char] -> DynFlags -> DynFlags
setOutputFile Maybe [Char]
f DynFlags
d = DynFlags
d { outputFile_ :: Maybe [Char]
outputFile_ = Maybe [Char]
f}
setDynOutputFile :: Maybe [Char] -> DynFlags -> DynFlags
setDynOutputFile Maybe [Char]
f DynFlags
d = DynFlags
d { dynOutputFile_ :: Maybe [Char]
dynOutputFile_ = Maybe [Char]
f}
setOutputHi :: Maybe [Char] -> DynFlags -> DynFlags
setOutputHi Maybe [Char]
f DynFlags
d = DynFlags
d { outputHi :: Maybe [Char]
outputHi = Maybe [Char]
f}
setDynOutputHi :: Maybe [Char] -> DynFlags -> DynFlags
setDynOutputHi Maybe [Char]
f DynFlags
d = DynFlags
d { dynOutputHi :: Maybe [Char]
dynOutputHi = Maybe [Char]
f}
parseUnitInsts :: String -> Instantiations
parseUnitInsts :: [Char] -> [(ModuleName, Module)]
parseUnitInsts [Char]
str = case (([(ModuleName, Module)], [Char]) -> Bool)
-> [([(ModuleName, Module)], [Char])]
-> [([(ModuleName, Module)], [Char])]
forall a. (a -> Bool) -> [a] -> [a]
filter (([Char] -> [Char] -> Bool
forall a. Eq a => a -> a -> Bool
==[Char]
"")([Char] -> Bool)
-> (([(ModuleName, Module)], [Char]) -> [Char])
-> ([(ModuleName, Module)], [Char])
-> Bool
forall b c a. (b -> c) -> (a -> b) -> a -> c
.([(ModuleName, Module)], [Char]) -> [Char]
forall a b. (a, b) -> b
snd) (ReadP [(ModuleName, Module)] -> ReadS [(ModuleName, Module)]
forall a. ReadP a -> ReadS a
readP_to_S ReadP [(ModuleName, Module)]
parse [Char]
str) of
[([(ModuleName, Module)]
r, [Char]
"")] -> [(ModuleName, Module)]
r
[([(ModuleName, Module)], [Char])]
_ -> GhcException -> [(ModuleName, Module)]
forall a. GhcException -> a
throwGhcException (GhcException -> [(ModuleName, Module)])
-> GhcException -> [(ModuleName, Module)]
forall a b. (a -> b) -> a -> b
$ [Char] -> GhcException
CmdLineError ([Char]
"Can't parse -instantiated-with: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
str)
where parse :: ReadP [(ModuleName, Module)]
parse = ReadP (ModuleName, Module)
-> ReadP Char -> ReadP [(ModuleName, Module)]
forall a sep. ReadP a -> ReadP sep -> ReadP [a]
sepBy ReadP (ModuleName, Module)
parseEntry (Char -> ReadP Char
R.char Char
',')
parseEntry :: ReadP (ModuleName, Module)
parseEntry = do
ModuleName
n <- ReadP ModuleName
parseModuleName
Char
_ <- Char -> ReadP Char
R.char Char
'='
Module
m <- ReadP Module
parseHoleyModule
(ModuleName, Module) -> ReadP (ModuleName, Module)
forall a. a -> ReadP a
forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
n, Module
m)
setUnitInstantiations :: String -> DynFlags -> DynFlags
setUnitInstantiations :: [Char] -> DynFlags -> DynFlags
setUnitInstantiations [Char]
s DynFlags
d =
DynFlags
d { homeUnitInstantiations_ :: [(ModuleName, Module)]
homeUnitInstantiations_ = [Char] -> [(ModuleName, Module)]
parseUnitInsts [Char]
s }
setUnitInstanceOf :: String -> DynFlags -> DynFlags
setUnitInstanceOf :: [Char] -> DynFlags -> DynFlags
setUnitInstanceOf [Char]
s DynFlags
d =
DynFlags
d { homeUnitInstanceOf_ :: Maybe UnitId
homeUnitInstanceOf_ = UnitId -> Maybe UnitId
forall a. a -> Maybe a
Just (FastString -> UnitId
UnitId ([Char] -> FastString
fsLit [Char]
s)) }
addPluginModuleName :: String -> DynFlags -> DynFlags
addPluginModuleName :: [Char] -> DynFlags -> DynFlags
addPluginModuleName [Char]
name DynFlags
d = DynFlags
d { pluginModNames :: [ModuleName]
pluginModNames = ([Char] -> ModuleName
mkModuleName [Char]
name) ModuleName -> [ModuleName] -> [ModuleName]
forall a. a -> [a] -> [a]
: (DynFlags -> [ModuleName]
pluginModNames DynFlags
d) }
clearPluginModuleNames :: DynFlags -> DynFlags
clearPluginModuleNames :: DynFlags -> DynFlags
clearPluginModuleNames DynFlags
d =
DynFlags
d { pluginModNames :: [ModuleName]
pluginModNames = []
, pluginModNameOpts :: [(ModuleName, [Char])]
pluginModNameOpts = []
}
addPluginModuleNameOption :: String -> DynFlags -> DynFlags
addPluginModuleNameOption :: [Char] -> DynFlags -> DynFlags
addPluginModuleNameOption [Char]
optflag DynFlags
d = DynFlags
d { pluginModNameOpts :: [(ModuleName, [Char])]
pluginModNameOpts = ([Char] -> ModuleName
mkModuleName [Char]
m, [Char]
option) (ModuleName, [Char])
-> [(ModuleName, [Char])] -> [(ModuleName, [Char])]
forall a. a -> [a] -> [a]
: (DynFlags -> [(ModuleName, [Char])]
pluginModNameOpts DynFlags
d) }
where ([Char]
m, [Char]
rest) = (Char -> Bool) -> [Char] -> ([Char], [Char])
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
== Char
':') [Char]
optflag
option :: [Char]
option = case [Char]
rest of
[] -> [Char]
""
(Char
_:[Char]
plug_opt) -> [Char]
plug_opt
addFrontendPluginOption :: String -> DynFlags -> DynFlags
addFrontendPluginOption :: [Char] -> DynFlags -> DynFlags
addFrontendPluginOption [Char]
s DynFlags
d = DynFlags
d { frontendPluginOpts :: [[Char]]
frontendPluginOpts = [Char]
s [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: DynFlags -> [[Char]]
frontendPluginOpts DynFlags
d }
parseDynLibLoaderMode :: [Char] -> DynFlags -> DynFlags
parseDynLibLoaderMode [Char]
f DynFlags
d =
case Int -> [Char] -> ([Char], [Char])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
8 [Char]
f of
([Char]
"deploy", [Char]
"") -> DynFlags
d { dynLibLoader :: DynLibLoader
dynLibLoader = DynLibLoader
Deployable }
([Char]
"sysdep", [Char]
"") -> DynFlags
d { dynLibLoader :: DynLibLoader
dynLibLoader = DynLibLoader
SystemDependent }
([Char], [Char])
_ -> GhcException -> DynFlags
forall a. GhcException -> a
throwGhcException ([Char] -> GhcException
CmdLineError ([Char]
"Unknown dynlib loader: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
f))
setDumpPrefixForce :: Maybe [Char] -> DynFlags -> DynFlags
setDumpPrefixForce Maybe [Char]
f DynFlags
d = DynFlags
d { dumpPrefixForce :: Maybe [Char]
dumpPrefixForce = Maybe [Char]
f}
setPgmP :: [Char] -> DynFlags -> DynFlags
setPgmP [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_pgm_P :: ([Char], [Option])
toolSettings_pgm_P = ([Char]
pgm, ([Char] -> Option) -> [[Char]] -> [Option]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Option
Option [[Char]]
args)})
where ([Char]
pgm:[[Char]]
args) = [Char] -> [[Char]]
words [Char]
f
addOptl :: [Char] -> DynFlags -> DynFlags
addOptl [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_l :: [[Char]]
toolSettings_opt_l = [Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_l ToolSettings
s})
addOptc :: [Char] -> DynFlags -> DynFlags
addOptc [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_c :: [[Char]]
toolSettings_opt_c = [Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_c ToolSettings
s})
addOptcxx :: [Char] -> DynFlags -> DynFlags
addOptcxx [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_cxx :: [[Char]]
toolSettings_opt_cxx = [Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_cxx ToolSettings
s})
addOptP :: [Char] -> DynFlags -> DynFlags
addOptP [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
{ toolSettings_opt_P :: [[Char]]
toolSettings_opt_P = [Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_P ToolSettings
s
, toolSettings_opt_P_fingerprint :: Fingerprint
toolSettings_opt_P_fingerprint = [[Char]] -> Fingerprint
fingerprintStrings ([Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_P ToolSettings
s)
}
where
fingerprintStrings :: [[Char]] -> Fingerprint
fingerprintStrings [[Char]]
ss = [Fingerprint] -> Fingerprint
fingerprintFingerprints ([Fingerprint] -> Fingerprint) -> [Fingerprint] -> Fingerprint
forall a b. (a -> b) -> a -> b
$ ([Char] -> Fingerprint) -> [[Char]] -> [Fingerprint]
forall a b. (a -> b) -> [a] -> [b]
map [Char] -> Fingerprint
fingerprintString [[Char]]
ss
setDepMakefile :: FilePath -> DynFlags -> DynFlags
setDepMakefile :: [Char] -> DynFlags -> DynFlags
setDepMakefile [Char]
f DynFlags
d = DynFlags
d { depMakefile :: [Char]
depMakefile = [Char]
f }
setDepIncludeCppDeps :: Bool -> DynFlags -> DynFlags
setDepIncludeCppDeps :: Bool -> DynFlags -> DynFlags
setDepIncludeCppDeps Bool
b DynFlags
d = DynFlags
d { depIncludeCppDeps :: Bool
depIncludeCppDeps = Bool
b }
setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
setDepIncludePkgDeps Bool
b DynFlags
d = DynFlags
d { depIncludePkgDeps :: Bool
depIncludePkgDeps = Bool
b }
addDepExcludeMod :: String -> DynFlags -> DynFlags
addDepExcludeMod :: [Char] -> DynFlags -> DynFlags
addDepExcludeMod [Char]
m DynFlags
d
= DynFlags
d { depExcludeMods :: [ModuleName]
depExcludeMods = [Char] -> ModuleName
mkModuleName [Char]
m ModuleName -> [ModuleName] -> [ModuleName]
forall a. a -> [a] -> [a]
: DynFlags -> [ModuleName]
depExcludeMods DynFlags
d }
addDepSuffix :: FilePath -> DynFlags -> DynFlags
addDepSuffix :: [Char] -> DynFlags -> DynFlags
addDepSuffix [Char]
s DynFlags
d = DynFlags
d { depSuffixes :: [[Char]]
depSuffixes = [Char]
s [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: DynFlags -> [[Char]]
depSuffixes DynFlags
d }
addCmdlineFramework :: [Char] -> DynFlags -> DynFlags
addCmdlineFramework [Char]
f DynFlags
d = DynFlags
d { cmdlineFrameworks :: [[Char]]
cmdlineFrameworks = [Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: DynFlags -> [[Char]]
cmdlineFrameworks DynFlags
d}
addGhcVersionFile :: FilePath -> DynFlags -> DynFlags
addGhcVersionFile :: [Char] -> DynFlags -> DynFlags
addGhcVersionFile [Char]
f DynFlags
d = DynFlags
d { ghcVersionFile :: Maybe [Char]
ghcVersionFile = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f }
addHaddockOpts :: [Char] -> DynFlags -> DynFlags
addHaddockOpts [Char]
f DynFlags
d = DynFlags
d { haddockOptions :: Maybe [Char]
haddockOptions = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
addGhciScript :: [Char] -> DynFlags -> DynFlags
addGhciScript [Char]
f DynFlags
d = DynFlags
d { ghciScripts :: [[Char]]
ghciScripts = [Char]
f [Char] -> [[Char]] -> [[Char]]
forall a. a -> [a] -> [a]
: DynFlags -> [[Char]]
ghciScripts DynFlags
d}
setInteractivePrint :: [Char] -> DynFlags -> DynFlags
setInteractivePrint [Char]
f DynFlags
d = DynFlags
d { interactivePrint :: Maybe [Char]
interactivePrint = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just [Char]
f}
updOptLevelChanged :: Int -> DynFlags -> (DynFlags, Bool)
updOptLevelChanged :: Int -> DynFlags -> (DynFlags, Bool)
updOptLevelChanged Int
n DynFlags
dfs
= (DynFlags
dfs3, Bool
changed1 Bool -> Bool -> Bool
|| Bool
changed2 Bool -> Bool -> Bool
|| Bool
changed3)
where
final_n :: Int
final_n = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
2 Int
n)
(DynFlags
dfs1, Bool
changed1) = (GeneralFlag -> (DynFlags, Bool) -> (DynFlags, Bool))
-> (DynFlags, Bool) -> [GeneralFlag] -> (DynFlags, Bool)
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> (DynFlags, Bool) -> (DynFlags, Bool)
unset (DynFlags
dfs , Bool
False) [GeneralFlag]
remove_gopts
(DynFlags
dfs2, Bool
changed2) = (GeneralFlag -> (DynFlags, Bool) -> (DynFlags, Bool))
-> (DynFlags, Bool) -> [GeneralFlag] -> (DynFlags, Bool)
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> (DynFlags, Bool) -> (DynFlags, Bool)
set (DynFlags
dfs1, Bool
False) [GeneralFlag]
extra_gopts
(DynFlags
dfs3, Bool
changed3) = DynFlags -> (DynFlags, Bool)
setLlvmOptLevel DynFlags
dfs2
extra_gopts :: [GeneralFlag]
extra_gopts = [ GeneralFlag
f | ([Int]
ns,GeneralFlag
f) <- [([Int], GeneralFlag)]
optLevelFlags, Int
final_n Int -> [Int] -> Bool
forall a. Eq a => a -> [a] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int]
ns ]
remove_gopts :: [GeneralFlag]
remove_gopts = [ GeneralFlag
f | ([Int]
ns,GeneralFlag
f) <- [([Int], GeneralFlag)]
optLevelFlags, Int
final_n Int -> [Int] -> Bool
forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [Int]
ns ]
set :: GeneralFlag -> (DynFlags, Bool) -> (DynFlags, Bool)
set GeneralFlag
f (DynFlags
dfs, Bool
changed)
| GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
f DynFlags
dfs = (DynFlags
dfs, Bool
changed)
| Bool
otherwise = (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dfs GeneralFlag
f, Bool
True)
unset :: GeneralFlag -> (DynFlags, Bool) -> (DynFlags, Bool)
unset GeneralFlag
f (DynFlags
dfs, Bool
changed)
| Bool -> Bool
not (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
f DynFlags
dfs) = (DynFlags
dfs, Bool
changed)
| Bool
otherwise = (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dfs GeneralFlag
f, Bool
True)
setLlvmOptLevel :: DynFlags -> (DynFlags, Bool)
setLlvmOptLevel DynFlags
dfs
| DynFlags -> Int
llvmOptLevel DynFlags
dfs Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
/= Int
final_n = (DynFlags
dfs{ llvmOptLevel :: Int
llvmOptLevel = Int
final_n }, Bool
True)
| Bool
otherwise = (DynFlags
dfs, Bool
False)
updOptLevel :: Int -> DynFlags -> DynFlags
updOptLevel :: Int -> DynFlags -> DynFlags
updOptLevel Int
n = (DynFlags, Bool) -> DynFlags
forall a b. (a, b) -> a
fst ((DynFlags, Bool) -> DynFlags)
-> (DynFlags -> (DynFlags, Bool)) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> DynFlags -> (DynFlags, Bool)
updOptLevelChanged Int
n
parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String]
-> m (DynFlags, [Located String], [Warn])
parseDynamicFlagsCmdLine :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> [Located [Char]] -> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFlagsCmdLine = [Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], [Warn])
forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
flagsAll Bool
True
parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String]
-> m (DynFlags, [Located String], [Warn])
parseDynamicFilePragma :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> [Located [Char]] -> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFilePragma = [Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], [Warn])
forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
flagsDynamic Bool
False
newtype CmdLineP s a = CmdLineP (forall m. (Monad m) => StateT s m a)
instance Monad (CmdLineP s) where
CmdLineP forall (m :: * -> *). Monad m => StateT s m a
k >>= :: forall a b. CmdLineP s a -> (a -> CmdLineP s b) -> CmdLineP s b
>>= a -> CmdLineP s b
f = (forall (m :: * -> *). Monad m => StateT s m b) -> CmdLineP s b
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (StateT s m a
forall (m :: * -> *). Monad m => StateT s m a
k StateT s m a -> (a -> StateT s m b) -> StateT s m b
forall a b. StateT s m a -> (a -> StateT s m b) -> StateT s m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> case a -> CmdLineP s b
f a
x of CmdLineP forall (m :: * -> *). Monad m => StateT s m b
g -> StateT s m b
forall (m :: * -> *). Monad m => StateT s m b
g)
return :: forall a. a -> CmdLineP s a
return = a -> CmdLineP s a
forall a. a -> CmdLineP s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure
instance Applicative (CmdLineP s) where
pure :: forall a. a -> CmdLineP s a
pure a
x = (forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (a -> StateT s m a
forall a. a -> StateT s m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
<*> :: forall a b. CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b
(<*>) = CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap
instance Functor (CmdLineP s) where
fmap :: forall a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
fmap a -> b
f (CmdLineP forall (m :: * -> *). Monad m => StateT s m a
k) = (forall (m :: * -> *). Monad m => StateT s m b) -> CmdLineP s b
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP ((a -> b) -> StateT s m a -> StateT s m b
forall a b. (a -> b) -> StateT s m a -> StateT s m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f StateT s m a
forall (m :: * -> *). Monad m => StateT s m a
k)
getCmdLineState :: CmdLineP s s
getCmdLineState :: forall s. CmdLineP s s
getCmdLineState = (forall (m :: * -> *). Monad m => StateT s m s) -> CmdLineP s s
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP StateT s m s
forall (m :: * -> *). Monad m => StateT s m s
forall (m :: * -> *) s. Monad m => StateT s m s
State.get
putCmdLineState :: s -> CmdLineP s ()
putCmdLineState :: forall s. s -> CmdLineP s ()
putCmdLineState s
x = (forall (m :: * -> *). Monad m => StateT s m ()) -> CmdLineP s ()
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (s -> StateT s m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
State.put s
x)
runCmdLineP :: CmdLineP s a -> s -> (a, s)
runCmdLineP :: forall s a. CmdLineP s a -> s -> (a, s)
runCmdLineP (CmdLineP forall (m :: * -> *). Monad m => StateT s m a
k) s
s0 = Identity (a, s) -> (a, s)
forall a. Identity a -> a
runIdentity (Identity (a, s) -> (a, s)) -> Identity (a, s) -> (a, s)
forall a b. (a -> b) -> a -> b
$ StateT s Identity a -> s -> Identity (a, s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT s Identity a
forall (m :: * -> *). Monad m => StateT s m a
k s
s0
processCmdLineP
:: forall s m. MonadIO m
=> [Flag (CmdLineP s)]
-> s
-> [Located String]
-> m (([Located String], [Err], [Warn]), s)
processCmdLineP :: forall s (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP s)]
-> s
-> [Located [Char]]
-> m (([Located [Char]], [Err], [Warn]), s)
processCmdLineP [Flag (CmdLineP s)]
activeFlags s
s0 [Located [Char]]
args =
StateT s m ([Located [Char]], [Err], [Warn])
-> s -> m (([Located [Char]], [Err], [Warn]), s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT ([Flag (StateT s m)]
-> [Located [Char]]
-> ([Char] -> EwM (StateT s m) [Located [Char]])
-> StateT s m ([Located [Char]], [Err], [Warn])
forall (m :: * -> *).
Monad m =>
[Flag m]
-> [Located [Char]]
-> ([Char] -> EwM m [Located [Char]])
-> m ([Located [Char]], [Err], [Warn])
processArgs ((Flag (CmdLineP s) -> Flag (StateT s m))
-> [Flag (CmdLineP s)] -> [Flag (StateT s m)]
forall a b. (a -> b) -> [a] -> [b]
map ((forall a. CmdLineP s a -> StateT s m a)
-> Flag (CmdLineP s) -> Flag (StateT s m)
forall (m :: * -> *) (n :: * -> *).
(forall a. m a -> n a) -> Flag m -> Flag n
hoistFlag CmdLineP s a -> StateT s m a
forall a. CmdLineP s a -> StateT s m a
getCmdLineP) [Flag (CmdLineP s)]
activeFlags) [Located [Char]]
args [Char] -> EwM (StateT s m) [Located [Char]]
forall (m :: * -> *). MonadIO m => [Char] -> EwM m [Located [Char]]
parseResponseFile) s
s0
where
getCmdLineP :: CmdLineP s a -> StateT s m a
getCmdLineP :: forall a. CmdLineP s a -> StateT s m a
getCmdLineP (CmdLineP forall (m :: * -> *). Monad m => StateT s m a
k) = StateT s m a
forall (m :: * -> *). Monad m => StateT s m a
k
parseDynamicFlagsFull
:: forall m. MonadIO m
=> [Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located String]
-> m (DynFlags, [Located String], [Warn])
parseDynamicFlagsFull :: forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
activeFlags Bool
cmdline DynFlags
dflags0 [Located [Char]]
args = do
(([Located [Char]]
leftover, [Err]
errs, [Warn]
warns), DynFlags
dflags1) <- [Flag (CmdLineP DynFlags)]
-> DynFlags
-> [Located [Char]]
-> m (([Located [Char]], [Err], [Warn]), DynFlags)
forall s (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP s)]
-> s
-> [Located [Char]]
-> m (([Located [Char]], [Err], [Warn]), s)
processCmdLineP [Flag (CmdLineP DynFlags)]
activeFlags DynFlags
dflags0 [Located [Char]]
args
let rdr :: SDoc -> [Char]
rdr = SDocContext -> SDoc -> [Char]
renderWithContext (DynFlags -> PprStyle -> SDocContext
initSDocContext DynFlags
dflags0 PprStyle
defaultUserStyle)
Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless ([Err] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Err]
errs) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ GhcException -> IO ()
forall a. GhcException -> IO a
throwGhcExceptionIO (GhcException -> IO ()) -> GhcException -> IO ()
forall a b. (a -> b) -> a -> b
$ [([Char], [Char])] -> GhcException
errorsToGhcException ([([Char], [Char])] -> GhcException)
-> [([Char], [Char])] -> GhcException
forall a b. (a -> b) -> a -> b
$
(Err -> ([Char], [Char])) -> [Err] -> [([Char], [Char])]
forall a b. (a -> b) -> [a] -> [b]
map ((SDoc -> [Char]
rdr (SDoc -> [Char])
-> (Located [Char] -> SDoc) -> Located [Char] -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SrcSpan -> SDoc
forall a. Outputable a => a -> SDoc
ppr (SrcSpan -> SDoc)
-> (Located [Char] -> SrcSpan) -> Located [Char] -> SDoc
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Located [Char] -> SrcSpan
forall l e. GenLocated l e -> l
getLoc (Located [Char] -> [Char])
-> (Located [Char] -> [Char]) -> Located [Char] -> ([Char], [Char])
forall b c c'. (b -> c) -> (b -> c') -> b -> (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& Located [Char] -> [Char]
forall l e. GenLocated l e -> e
unLoc) (Located [Char] -> ([Char], [Char]))
-> (Err -> Located [Char]) -> Err -> ([Char], [Char])
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Err -> Located [Char]
errMsg) ([Err] -> [([Char], [Char])]) -> [Err] -> [([Char], [Char])]
forall a b. (a -> b) -> a -> b
$ [Err]
errs
let (DynFlags
dflags2, [Located [Char]]
sh_warns) = Bool -> DynFlags -> (DynFlags, [Located [Char]])
safeFlagCheck Bool
cmdline DynFlags
dflags1
theWays :: Ways
theWays = DynFlags -> Ways
ways DynFlags
dflags2
Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Ways -> Bool
allowed_combination Ways
theWays) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$
GhcException -> IO ()
forall a. GhcException -> IO a
throwGhcExceptionIO ([Char] -> GhcException
CmdLineError ([Char]
"combination not supported: " [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++
[Char] -> [[Char]] -> [Char]
forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"/" ((Way -> [Char]) -> [Way] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Way -> [Char]
wayDesc (Ways -> [Way]
forall a. Set a -> [a]
Set.toAscList Ways
theWays))))
let (DynFlags
dflags3, [Located [Char]]
consistency_warnings) = DynFlags -> (DynFlags, [Located [Char]])
makeDynFlagsConsistent DynFlags
dflags2
Bool -> m () -> m ()
forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DynFlags -> Bool
enableTimeStats DynFlags
dflags3) (m () -> m ()) -> m () -> m ()
forall a b. (a -> b) -> a -> b
$ IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO ()
enableTimingStats
case (DynFlags -> Maybe Int
ghcHeapSize DynFlags
dflags3) of
Just Int
x -> IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Int -> IO ()
setHeapSize Int
x)
Maybe Int
_ -> () -> m ()
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return ()
IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ DynFlags -> IO ()
setUnsafeGlobalDynFlags DynFlags
dflags3
let warns' :: [Warn]
warns' = (Located [Char] -> Warn) -> [Located [Char]] -> [Warn]
forall a b. (a -> b) -> [a] -> [b]
map (DiagnosticReason -> Located [Char] -> Warn
Warn DiagnosticReason
WarningWithoutFlag) ([Located [Char]]
consistency_warnings [Located [Char]] -> [Located [Char]] -> [Located [Char]]
forall a. [a] -> [a] -> [a]
++ [Located [Char]]
sh_warns)
(DynFlags, [Located [Char]], [Warn])
-> m (DynFlags, [Located [Char]], [Warn])
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags
dflags3, [Located [Char]]
leftover, [Warn]
warns' [Warn] -> [Warn] -> [Warn]
forall a. [a] -> [a] -> [a]
++ [Warn]
warns)
safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located String])
safeFlagCheck :: Bool -> DynFlags -> (DynFlags, [Located [Char]])
safeFlagCheck Bool
_ DynFlags
dflags | DynFlags -> Bool
safeLanguageOn DynFlags
dflags = (DynFlags
dflagsUnset, [Located [Char]]
warns)
where
(DynFlags
dflagsUnset, [Located [Char]]
warns) = ((DynFlags, [Located [Char]])
-> ([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)
-> (DynFlags, [Located [Char]]))
-> (DynFlags, [Located [Char]])
-> [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
-> (DynFlags, [Located [Char]])
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (DynFlags, [Located [Char]])
-> ([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)
-> (DynFlags, [Located [Char]])
forall {a} {l}.
(a, [GenLocated l [Char]])
-> ([Char], a -> l, a -> Bool, a -> a)
-> (a, [GenLocated l [Char]])
check_method (DynFlags
dflags, []) [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
unsafeFlags
check_method :: (a, [GenLocated l [Char]])
-> ([Char], a -> l, a -> Bool, a -> a)
-> (a, [GenLocated l [Char]])
check_method (a
df, [GenLocated l [Char]]
warns) ([Char]
str,a -> l
loc,a -> Bool
test,a -> a
fix)
| a -> Bool
test a
df = (a -> a
fix a
df, [GenLocated l [Char]]
warns [GenLocated l [Char]]
-> [GenLocated l [Char]] -> [GenLocated l [Char]]
forall a. [a] -> [a] -> [a]
++ l -> [Char] -> [GenLocated l [Char]]
forall {l}. l -> [Char] -> [GenLocated l [Char]]
safeFailure (a -> l
loc a
df) [Char]
str)
| Bool
otherwise = (a
df, [GenLocated l [Char]]
warns)
safeFailure :: l -> [Char] -> [GenLocated l [Char]]
safeFailure l
loc [Char]
str
= [l -> [Char] -> GenLocated l [Char]
forall l e. l -> e -> GenLocated l e
L l
loc ([Char] -> GenLocated l [Char]) -> [Char] -> GenLocated l [Char]
forall a b. (a -> b) -> a -> b
$ [Char]
str [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
" is not allowed in Safe Haskell; ignoring "
[Char] -> ShowS
forall a. [a] -> [a] -> [a]
++ [Char]
str]
safeFlagCheck Bool
cmdl DynFlags
dflags =
case DynFlags -> Bool
safeInferOn DynFlags
dflags of
Bool
True -> (DynFlags
dflags' { safeInferred :: Bool
safeInferred = Bool
safeFlags }, [Located [Char]]
warn)
Bool
False -> (DynFlags
dflags', [Located [Char]]
warn)
where
(DynFlags
dflags', [Located [Char]]
warn)
| Bool -> Bool
not (DynFlags -> Bool
safeHaskellModeEnabled DynFlags
dflags) Bool -> Bool -> Bool
&& Bool -> Bool
not Bool
cmdl Bool -> Bool -> Bool
&& DynFlags -> Bool
packageTrustOn DynFlags
dflags
= (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_PackageTrust, [Located [Char]]
pkgWarnMsg)
| Bool
otherwise = (DynFlags
dflags, [])
pkgWarnMsg :: [Located [Char]]
pkgWarnMsg = [SrcSpan -> [Char] -> Located [Char]
forall l e. l -> e -> GenLocated l e
L (DynFlags -> SrcSpan
pkgTrustOnLoc DynFlags
dflags') ([Char] -> Located [Char]) -> [Char] -> Located [Char]
forall a b. (a -> b) -> a -> b
$
[Char]
"-fpackage-trust ignored;" [Char] -> ShowS
forall a. [a] -> [a] -> [a]
++
[Char]
" must be specified with a Safe Haskell flag"]
safeFlags :: Bool
safeFlags = (([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)
-> Bool)
-> [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
-> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\([Char]
_,DynFlags -> SrcSpan
_,DynFlags -> Bool
t,DynFlags -> DynFlags
_) -> Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ DynFlags -> Bool
t DynFlags
dflags) [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
DynFlags -> DynFlags)]
unsafeFlagsForInfer
allNonDeprecatedFlags :: [String]
allNonDeprecatedFlags :: [[Char]]
allNonDeprecatedFlags = Bool -> [[Char]]
allFlagsDeps Bool
False
allFlagsDeps :: Bool -> [String]
allFlagsDeps :: Bool -> [[Char]]
allFlagsDeps Bool
keepDeprecated = [ Char
'-'Char -> ShowS
forall a. a -> [a] -> [a]
:Flag (CmdLineP DynFlags) -> [Char]
forall (m :: * -> *). Flag m -> [Char]
flagName Flag (CmdLineP DynFlags)
flag
| (Deprecation
deprecated, Flag (CmdLineP DynFlags)
flag) <- [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps
, Bool
keepDeprecated Bool -> Bool -> Bool
|| Bool -> Bool
not (Deprecation -> Bool
isDeprecated Deprecation
deprecated)]
where isDeprecated :: Deprecation -> Bool
isDeprecated Deprecation
Deprecated = Bool
True
isDeprecated Deprecation
_ = Bool
False
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsAll = ((Deprecation, Flag (CmdLineP DynFlags))
-> Flag (CmdLineP DynFlags))
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [Flag (CmdLineP DynFlags)]
forall a b. (a -> b) -> [a] -> [b]
map (Deprecation, Flag (CmdLineP DynFlags)) -> Flag (CmdLineP DynFlags)
forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps
flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps = [(Deprecation, Flag (CmdLineP DynFlags))]
package_flags_deps [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsDynamic = ((Deprecation, Flag (CmdLineP DynFlags))
-> Flag (CmdLineP DynFlags))
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [Flag (CmdLineP DynFlags)]
forall a b. (a -> b) -> [a] -> [b]
map (Deprecation, Flag (CmdLineP DynFlags)) -> Flag (CmdLineP DynFlags)
forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps
flagsPackage :: [Flag (CmdLineP DynFlags)]
flagsPackage :: [Flag (CmdLineP DynFlags)]
flagsPackage = ((Deprecation, Flag (CmdLineP DynFlags))
-> Flag (CmdLineP DynFlags))
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [Flag (CmdLineP DynFlags)]
forall a b. (a -> b) -> [a] -> [b]
map (Deprecation, Flag (CmdLineP DynFlags)) -> Flag (CmdLineP DynFlags)
forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
package_flags_deps
type FlagMaker m = String -> OptKind m -> Flag m
type DynFlagMaker = FlagMaker (CmdLineP DynFlags)
data Deprecation = NotDeprecated | Deprecated deriving (Deprecation -> Deprecation -> Bool
(Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool) -> Eq Deprecation
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Deprecation -> Deprecation -> Bool
== :: Deprecation -> Deprecation -> Bool
$c/= :: Deprecation -> Deprecation -> Bool
/= :: Deprecation -> Deprecation -> Bool
Eq, Eq Deprecation
Eq Deprecation
-> (Deprecation -> Deprecation -> Ordering)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Bool)
-> (Deprecation -> Deprecation -> Deprecation)
-> (Deprecation -> Deprecation -> Deprecation)
-> Ord Deprecation
Deprecation -> Deprecation -> Bool
Deprecation -> Deprecation -> Ordering
Deprecation -> Deprecation -> Deprecation
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Deprecation -> Deprecation -> Ordering
compare :: Deprecation -> Deprecation -> Ordering
$c< :: Deprecation -> Deprecation -> Bool
< :: Deprecation -> Deprecation -> Bool
$c<= :: Deprecation -> Deprecation -> Bool
<= :: Deprecation -> Deprecation -> Bool
$c> :: Deprecation -> Deprecation -> Bool
> :: Deprecation -> Deprecation -> Bool
$c>= :: Deprecation -> Deprecation -> Bool
>= :: Deprecation -> Deprecation -> Bool
$cmax :: Deprecation -> Deprecation -> Deprecation
max :: Deprecation -> Deprecation -> Deprecation
$cmin :: Deprecation -> Deprecation -> Deprecation
min :: Deprecation -> Deprecation -> Deprecation
Ord)
make_ord_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag :: DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
fm [Char]
name OptKind (CmdLineP DynFlags)
kind = (Deprecation
NotDeprecated, DynFlagMaker
fm [Char]
name OptKind (CmdLineP DynFlags)
kind)
make_dep_flag :: DynFlagMaker -> String -> OptKind (CmdLineP DynFlags) -> String
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag :: DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
fm [Char]
name OptKind (CmdLineP DynFlags)
kind [Char]
message = (Deprecation
Deprecated,
DynFlagMaker
fm [Char]
name (OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags))
-> OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ OptKind (CmdLineP DynFlags)
-> [Char] -> OptKind (CmdLineP DynFlags)
add_dep_message OptKind (CmdLineP DynFlags)
kind [Char]
message)
add_dep_message :: OptKind (CmdLineP DynFlags) -> String
-> OptKind (CmdLineP DynFlags)
add_dep_message :: OptKind (CmdLineP DynFlags)
-> [Char] -> OptKind (CmdLineP DynFlags)
add_dep_message (NoArg DynP ()
f) [Char]
message = DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ DynP ()
f DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (HasArg [Char] -> DynP ()
f) [Char]
message = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (SepArg [Char] -> DynP ()
f) [Char]
message = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (Prefix [Char] -> DynP ()
f) [Char]
message = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (OptPrefix [Char] -> DynP ()
f) [Char]
message =
([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
OptPrefix (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (OptIntSuffix Maybe Int -> DynP ()
f) [Char]
message =
(Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix ((Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Maybe Int
oi -> Maybe Int -> DynP ()
f Maybe Int
oi DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (IntSuffix Int -> DynP ()
f) [Char]
message =
(Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Int -> EwM m ()) -> OptKind m
IntSuffix ((Int -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Int
i -> Int -> DynP ()
f Int
i DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (WordSuffix Word -> DynP ()
f) [Char]
message =
(Word -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Word -> EwM m ()) -> OptKind m
WordSuffix ((Word -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Word -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Word
i -> Word -> DynP ()
f Word
i DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>><