{-# OPTIONS_GHC -O0 #-}
{-# LANGUAGE CPP #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE LambdaCase #-}

-------------------------------------------------------------------------------
--
-- | Dynamic flags
--
-- Most flags are dynamic flags, which means they can change from compilation
-- to compilation using @OPTIONS_GHC@ pragmas, and in a multi-session GHC each
-- session can be using different dynamic flags. Dynamic flags can also be set
-- at the prompt in GHCi.
--
-- (c) The University of Glasgow 2005
--
-------------------------------------------------------------------------------

{-# OPTIONS_GHC -Wno-incomplete-uni-patterns #-}

module GHC.Driver.Session (
        -- * Dynamic flags and associated configuration types
        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,
        OnOff(..),
        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,

        -- ** Safe Haskell
        safeHaskellOn, safeHaskellModeEnabled,
        safeImportsOn, safeLanguageOn, safeInferOn,
        packageTrustOn,
        safeDirectImpsReq, safeImplicitImpsReq,
        unsafeFlags, unsafeFlagsForInfer,

        -- ** System tool settings and locations
        Settings(..),
        sProgramName,
        sProjectVersion,
        sGhcUsagePath,
        sGhciUsagePath,
        sToolDir,
        sTopDir,
        sGlobalPackageDatabasePath,
        sLdSupportsCompactUnwind,
        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_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_ar,
        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,

        -- ** Manipulating DynFlags
        addPluginModuleName,
        defaultDynFlags,                -- Settings -> DynFlags
        initDynFlags,                   -- DynFlags -> IO DynFlags
        defaultFatalMessager,
        defaultFlushOut,
        setOutputFile, setDynOutputFile, setOutputHi, setDynOutputHi,
        augmentByWorkingDirectory,

        getOpts,                        -- DynFlags -> (DynFlags -> [a]) -> [a]
        getVerbFlags,
        updOptLevel,
        setTmpDir,
        setUnitId,

        TurnOnFlag,
        turnOn,
        turnOff,
        impliedGFlags,
        impliedOffGFlags,
        impliedXFlags,

        -- ** State
        CmdLineP(..), runCmdLineP,
        getCmdLineState, putCmdLineState,
        processCmdLineP,

        -- ** Parsing DynFlags
        parseDynamicFlagsCmdLine,
        parseDynamicFilePragma,
        parseDynamicFlagsFull,

        -- ** Available DynFlags
        allNonDeprecatedFlags,
        flagsAll,
        flagsDynamic,
        flagsPackage,
        flagsForCompletion,

        supportedLanguagesAndExtensions,
        languageExtensions,

        -- ** DynFlags C compiler options
        picCCOpts, picPOpts,

        -- ** DynFlags C linker options
        pieCCLDOpts,

        -- * Compiler configuration suitable for display to the user
        compilerInfo,

        wordAlignment,

        setUnsafeGlobalDynFlags,

        -- * SSE and AVX
        isSse4_2Enabled,
        isBmiEnabled,
        isBmi2Enabled,
        isAvxEnabled,
        isAvx2Enabled,
        isAvx512cdEnabled,
        isAvx512erEnabled,
        isAvx512fEnabled,
        isAvx512pfEnabled,

        -- * Linker/compiler information
        LinkerInfo(..),
        CompilerInfo(..),
        useXLinkerRPath,

        -- * Include specifications
        IncludeSpecs(..), addGlobalInclude, addQuoteInclude, flattenIncludes,
        addImplicitQuoteInclude,

        -- * SDoc
        initSDocContext, initDefaultSDocContext,
        initPromotionTickContext,
  ) 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.Driver.Plugins.External
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 GHC.Types.ProfAuto
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

-- Note [Updating flag description in the User's Guide]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- If you modify anything in this file please make sure that your changes are
-- described in the User's Guide. Please update the flag description in the
-- users guide (docs/users_guide) whenever you add or change a flag.
-- Please make sure you add ":since:" information to new flags.

-- Note [Supporting CLI completion]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- The command line interface completion (in for example bash) is an easy way
-- for the developer to learn what flags are available from GHC.
-- GHC helps by separating which flags are available when compiling with GHC,
-- and which flags are available when using GHCi.
-- A flag is assumed to either work in both these modes, or only in one of them.
-- When adding or changing a flag, please consider for which mode the flag will
-- have effect, and annotate it accordingly. For Flags use defFlag, defGhcFlag,
-- defGhciFlag, and for FlagSpec use flagSpec or flagGhciSpec.

-- Note [Adding a language extension]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- There are a few steps to adding (or removing) a language extension,
--
--  * Adding the extension to GHC.LanguageExtensions
--
--    The Extension type in libraries/ghc-boot-th/GHC/LanguageExtensions/Type.hs
--    is the canonical list of language extensions known by GHC.
--
--  * Adding a flag to DynFlags.xFlags
--
--    This is fairly self-explanatory. The name should be concise, memorable,
--    and consistent with any previous implementations of the similar idea in
--    other Haskell compilers.
--
--  * Adding the flag to the documentation
--
--    This is the same as any other flag. See
--    Note [Updating flag description in the User's Guide]
--
--  * Adding the flag to Cabal
--
--    The Cabal library has its own list of all language extensions supported
--    by all major compilers. This is the list that user code being uploaded
--    to Hackage is checked against to ensure language extension validity.
--    Consequently, it is very important that this list remains up-to-date.
--
--    To this end, there is a testsuite test (testsuite/tests/driver/T4437.hs)
--    whose job it is to ensure these GHC's extensions are consistent with
--    Cabal.
--
--    The recommended workflow is,
--
--     1. Temporarily add your new language extension to the
--        expectedGhcOnlyExtensions list in T4437 to ensure the test doesn't
--        break while Cabal is updated.
--
--     2. After your GHC change is accepted, submit a Cabal pull request adding
--        your new extension to Cabal's list (found in
--        Cabal/Language/Haskell/Extension.hs).
--
--     3. After your Cabal change is accepted, let the GHC developers know so
--        they can update the Cabal submodule and remove the extensions from
--        expectedGhcOnlyExtensions.
--
--  * Adding the flag to the GHC Wiki
--
--    There is a change log tracking language extension additions and removals
--    on the GHC wiki:  https://gitlab.haskell.org/ghc/ghc/wikis/language-pragma-history
--
--  See #4437 and #8176.

-- -----------------------------------------------------------------------------
-- DynFlags

-- | Used to differentiate the scope an include needs to apply to.
-- We have to split the include paths to avoid accidentally forcing recursive
-- includes since -I overrides the system search paths. See #14312.
data IncludeSpecs
  = IncludeSpecs { IncludeSpecs -> [[Char]]
includePathsQuote  :: [String]
                 , IncludeSpecs -> [[Char]]
includePathsGlobal :: [String]
                 -- | See Note [Implicit include paths]
                 , IncludeSpecs -> [[Char]]
includePathsQuoteImplicit :: [String]
                 }
  deriving Int -> IncludeSpecs -> ShowS
[IncludeSpecs] -> ShowS
IncludeSpecs -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [IncludeSpecs] -> ShowS
$cshowList :: [IncludeSpecs] -> ShowS
show :: IncludeSpecs -> [Char]
$cshow :: IncludeSpecs -> [Char]
showsPrec :: Int -> IncludeSpecs -> ShowS
$cshowsPrec :: Int -> IncludeSpecs -> ShowS
Show

-- | Append to the list of includes a path that shall be included using `-I`
-- when the C compiler is called. These paths override system search paths.
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 forall a. [a] -> [a] -> [a]
++ [[Char]]
paths }

-- | Append to the list of includes a path that shall be included using
-- `-iquote` when the C compiler is called. These paths only apply when quoted
-- includes are used. e.g. #include "foo.h"
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 forall a. [a] -> [a] -> [a]
++ [[Char]]
paths }

-- | These includes are not considered while fingerprinting the flags for iface
-- | See Note [Implicit include 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 forall a. [a] -> [a] -> [a]
++ [[Char]]
paths }


-- | Concatenate and flatten the list of global and quoted includes returning
-- just a flat list of paths.
flattenIncludes :: IncludeSpecs -> [String]
flattenIncludes :: IncludeSpecs -> [[Char]]
flattenIncludes IncludeSpecs
specs =
    IncludeSpecs -> [[Char]]
includePathsQuote IncludeSpecs
specs forall a. [a] -> [a] -> [a]
++
    IncludeSpecs -> [[Char]]
includePathsQuoteImplicit IncludeSpecs
specs forall a. [a] -> [a] -> [a]
++
    IncludeSpecs -> [[Char]]
includePathsGlobal IncludeSpecs
specs

{- Note [Implicit include paths]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  The compile driver adds the path to the folder containing the source file being
  compiled to the 'IncludeSpecs', and this change gets recorded in the 'DynFlags'
  that are used later to compute the interface file. Because of this,
  the flags fingerprint derived from these 'DynFlags' and recorded in the
  interface file will end up containing the absolute path to the source folder.

  Build systems with a remote cache like Bazel or Buck (or Shake, see #16956)
  store the build artifacts produced by a build BA for reuse in subsequent builds.

  Embedding source paths in interface fingerprints will thwart these attempts and
  lead to unnecessary recompilations when the source paths in BA differ from the
  source paths in subsequent builds.
 -}


-- | Contains not only a collection of 'GeneralFlag's but also a plethora of
-- information relating to the compilation of a single file or GHC session
data DynFlags = DynFlags {
  DynFlags -> GhcMode
ghcMode               :: GhcMode,
  DynFlags -> GhcLink
ghcLink               :: GhcLink,
  DynFlags -> Backend
backend               :: !Backend,
   -- ^ The backend to use (if any).
   --
   -- Whenever you change the backend, also make sure to set 'ghcLink' to
   -- something sensible.
   --
   -- 'NoBackend' can be used to avoid generating any output, however, note that:
   --
   --  * If a program uses Template Haskell the typechecker may need to run code
   --    from an imported module.  To facilitate this, code generation is enabled
   --    for modules imported by modules that use template haskell, using the
   --    default backend for the platform.
   --    See Note [-fno-code mode].


  -- formerly Settings
  DynFlags -> GhcNameVersion
ghcNameVersion    :: {-# UNPACK #-} !GhcNameVersion,
  DynFlags -> FileSettings
fileSettings      :: {-# UNPACK #-} !FileSettings,
  DynFlags -> Platform
targetPlatform    :: Platform,       -- Filled in by SysTools
  DynFlags -> ToolSettings
toolSettings      :: {-# UNPACK #-} !ToolSettings,
  DynFlags -> PlatformMisc
platformMisc      :: {-# UNPACK #-} !PlatformMisc,
  DynFlags -> [([Char], [Char])]
rawSettings       :: [(String, String)],
  DynFlags -> TempDir
tmpDir            :: TempDir,

  DynFlags -> Int
llvmOptLevel          :: Int,         -- ^ LLVM optimisation level
  DynFlags -> Int
verbosity             :: Int,         -- ^ Verbosity level: see Note [Verbosity levels]
  DynFlags -> Int
debugLevel            :: Int,         -- ^ How much debug information to produce
  DynFlags -> Int
simplPhases           :: Int,         -- ^ Number of simplifier phases
  DynFlags -> Int
maxSimplIterations    :: Int,         -- ^ Max simplifier iterations
  DynFlags -> Maybe [Char]
ruleCheck             :: Maybe String,
  DynFlags -> [Int]
strictnessBefore      :: [Int],       -- ^ Additional demand analysis

  DynFlags -> Maybe Int
parMakeCount          :: Maybe Int,   -- ^ The number of modules to compile in parallel
                                        --   in --make mode, where Nothing ==> compile as
                                        --   many in parallel as there are CPUs.

  DynFlags -> Bool
enableTimeStats       :: Bool,        -- ^ Enable RTS timing statistics?
  DynFlags -> Maybe Int
ghcHeapSize           :: Maybe Int,   -- ^ The heap size to set.

  DynFlags -> Maybe Int
maxRelevantBinds      :: Maybe Int,   -- ^ Maximum number of bindings from the type envt
                                        --   to show in type error messages
  DynFlags -> Maybe Int
maxValidHoleFits      :: Maybe Int,   -- ^ Maximum number of hole fits to show
                                        --   in typed hole error messages
  DynFlags -> Maybe Int
maxRefHoleFits        :: Maybe Int,   -- ^ Maximum number of refinement hole
                                        --   fits to show in typed hole error
                                        --   messages
  DynFlags -> Maybe Int
refLevelHoleFits      :: Maybe Int,   -- ^ Maximum level of refinement for
                                        --   refinement hole fits in typed hole
                                        --   error messages
  DynFlags -> Int
maxUncoveredPatterns  :: Int,         -- ^ Maximum number of unmatched patterns to show
                                        --   in non-exhaustiveness warnings
  DynFlags -> Int
maxPmCheckModels      :: Int,         -- ^ Soft limit on the number of models
                                        --   the pattern match checker checks
                                        --   a pattern against. A safe guard
                                        --   against exponential blow-up.
  DynFlags -> Int
simplTickFactor       :: Int,         -- ^ Multiplier for simplifier ticks
  DynFlags -> Int
dmdUnboxWidth         :: !Int,        -- ^ Whether DmdAnal should optimistically put an
                                        --   Unboxed demand on returned products with at most
                                        --   this number of fields
  DynFlags -> Maybe Int
specConstrThreshold   :: Maybe Int,   -- ^ Threshold for SpecConstr
  DynFlags -> Maybe Int
specConstrCount       :: Maybe Int,   -- ^ Max number of specialisations for any one function
  DynFlags -> Int
specConstrRecursive   :: Int,         -- ^ Max number of specialisations for recursive types
                                        --   Not optional; otherwise ForceSpecConstr can diverge.
  DynFlags -> Maybe Word
binBlobThreshold      :: Maybe Word,  -- ^ Binary literals (e.g. strings) whose size is above
                                        --   this threshold will be dumped in a binary file
                                        --   by the assembler code generator. 0 and Nothing disables
                                        --   this feature. See 'GHC.StgToCmm.Config'.
  DynFlags -> Maybe Int
liberateCaseThreshold :: Maybe Int,   -- ^ Threshold for LiberateCase
  DynFlags -> Maybe Int
floatLamArgs          :: Maybe Int,   -- ^ Arg count for lambda floating
                                        --   See 'GHC.Core.Opt.Monad.FloatOutSwitches'

  DynFlags -> Maybe Int
liftLamsRecArgs       :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a
                                        --   recursive function.
  DynFlags -> Maybe Int
liftLamsNonRecArgs    :: Maybe Int,   -- ^ Maximum number of arguments after lambda lifting a
                                        --   non-recursive function.
  DynFlags -> Bool
liftLamsKnown         :: Bool,        -- ^ Lambda lift even when this turns a known call
                                        --   into an unknown call.

  DynFlags -> Maybe Int
cmmProcAlignment      :: Maybe Int,   -- ^ Align Cmm functions at this boundary or use default.

  DynFlags -> Int
historySize           :: Int,         -- ^ Simplification history size

  DynFlags -> [[Char]]
importPaths           :: [FilePath],
  DynFlags -> ModuleName
mainModuleNameIs      :: ModuleName,
  DynFlags -> Maybe [Char]
mainFunIs             :: Maybe String,
  DynFlags -> IntWithInf
reductionDepth        :: IntWithInf,   -- ^ Typechecker maximum stack depth
  DynFlags -> IntWithInf
solverIterations      :: IntWithInf,   -- ^ Number of iterations in the constraints solver
                                         --   Typically only 1 is needed

  DynFlags -> UnitId
homeUnitId_             :: UnitId,                 -- ^ Target home unit-id
  DynFlags -> Maybe UnitId
homeUnitInstanceOf_     :: Maybe UnitId,           -- ^ Id of the unit to instantiate
  DynFlags -> [(ModuleName, Module)]
homeUnitInstantiations_ :: [(ModuleName, Module)], -- ^ Module instantiations

  -- Note [Filepaths and Multiple Home Units]
  DynFlags -> Maybe [Char]
workingDirectory      :: Maybe FilePath,
  DynFlags -> Maybe [Char]
thisPackageName       :: Maybe String, -- ^ What the package is called, use with multiple home units
  DynFlags -> Set ModuleName
hiddenModules         :: Set.Set ModuleName,
  DynFlags -> Set ModuleName
reexportedModules     :: Set.Set ModuleName,

  -- ways
  DynFlags -> Ways
targetWays_           :: Ways,         -- ^ Target way flags from the command line

  -- For object splitting
  DynFlags -> Maybe ([Char], Int)
splitInfo             :: Maybe (String,Int),

  -- paths etc.
  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, -- ^ Indicate if we are now generating dynamic output
                                  -- because of -dynamic-too. This predicate is
                                  -- used to query the appropriate fields
                                  -- (outputFile/dynOutputFile, ways, etc.)

  -- | This defaults to 'non-module'. It can be set by
  -- 'GHC.Driver.Pipeline.setDumpPrefix' or 'ghc.GHCi.UI.runStmt' based on
  -- where its output is going.
  DynFlags -> [Char]
dumpPrefix            :: FilePath,

  -- | Override the 'dumpPrefix' set by 'GHC.Driver.Pipeline.setDumpPrefix'
  --    or 'ghc.GHCi.UI.runStmt'.
  --    Set by @-ddump-file-prefix@
  DynFlags -> Maybe [Char]
dumpPrefixForce       :: Maybe FilePath,

  DynFlags -> [Option]
ldInputs              :: [Option],

  DynFlags -> IncludeSpecs
includePaths          :: IncludeSpecs,
  DynFlags -> [[Char]]
libraryPaths          :: [String],
  DynFlags -> [[Char]]
frameworkPaths        :: [String],    -- used on darwin only
  DynFlags -> [[Char]]
cmdlineFrameworks     :: [String],    -- ditto

  DynFlags -> Maybe [Char]
rtsOpts               :: Maybe String,
  DynFlags -> RtsOptsEnabled
rtsOptsEnabled        :: RtsOptsEnabled,
  DynFlags -> Bool
rtsOptsSuggestions    :: Bool,

  DynFlags -> [Char]
hpcDir                :: String,      -- ^ Path to store the .mix files

  -- Plugins
  DynFlags -> [ModuleName]
pluginModNames        :: [ModuleName],
    -- ^ the @-fplugin@ flags given on the command line, in *reverse*
    -- order that they're specified on the command line.
  DynFlags -> [(ModuleName, [Char])]
pluginModNameOpts     :: [(ModuleName,String)],
  DynFlags -> [[Char]]
frontendPluginOpts    :: [String],
    -- ^ the @-ffrontend-opt@ flags given on the command line, in *reverse*
    -- order that they're specified on the command line.

  DynFlags -> [ExternalPluginSpec]
externalPluginSpecs   :: [ExternalPluginSpec],
    -- ^ External plugins loaded from shared libraries

  --  For ghc -M
  DynFlags -> [Char]
depMakefile           :: FilePath,
  DynFlags -> Bool
depIncludePkgDeps     :: Bool,
  DynFlags -> Bool
depIncludeCppDeps     :: Bool,
  DynFlags -> [ModuleName]
depExcludeMods        :: [ModuleName],
  DynFlags -> [[Char]]
depSuffixes           :: [String],

  --  Package flags
  DynFlags -> [PackageDBFlag]
packageDBFlags        :: [PackageDBFlag],
        -- ^ The @-package-db@ flags given on the command line, In
        -- *reverse* order that they're specified on the command line.
        -- This is intended to be applied with the list of "initial"
        -- package databases derived from @GHC_PACKAGE_PATH@; see
        -- 'getUnitDbRefs'.

  DynFlags -> [IgnorePackageFlag]
ignorePackageFlags    :: [IgnorePackageFlag],
        -- ^ The @-ignore-package@ flags from the command line.
        -- In *reverse* order that they're specified on the command line.
  DynFlags -> [PackageFlag]
packageFlags          :: [PackageFlag],
        -- ^ The @-package@ and @-hide-package@ flags from the command-line.
        -- In *reverse* order that they're specified on the command line.
  DynFlags -> [PackageFlag]
pluginPackageFlags    :: [PackageFlag],
        -- ^ The @-plugin-package-id@ flags from command line.
        -- In *reverse* order that they're specified on the command line.
  DynFlags -> [TrustFlag]
trustFlags            :: [TrustFlag],
        -- ^ The @-trust@ and @-distrust@ flags.
        -- In *reverse* order that they're specified on the command line.
  DynFlags -> Maybe [Char]
packageEnv            :: Maybe FilePath,
        -- ^ Filepath to the package environment file (if overriding default)


  -- hsc dynamic flags
  DynFlags -> EnumSet DumpFlag
dumpFlags             :: EnumSet DumpFlag,
  DynFlags -> EnumSet GeneralFlag
generalFlags          :: EnumSet GeneralFlag,
  DynFlags -> EnumSet WarningFlag
warningFlags          :: EnumSet WarningFlag,
  DynFlags -> EnumSet WarningFlag
fatalWarningFlags     :: EnumSet WarningFlag,
  -- Don't change this without updating extensionFlags:
  DynFlags -> Maybe Language
language              :: Maybe Language,
  -- | Safe Haskell mode
  DynFlags -> SafeHaskellMode
safeHaskell           :: SafeHaskellMode,
  DynFlags -> Bool
safeInfer             :: Bool,
  DynFlags -> Bool
safeInferred          :: Bool,
  -- We store the location of where some extension and flags were turned on so
  -- we can produce accurate error messages when Safe Haskell fails due to
  -- them.
  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,
  -- Don't change this without updating extensionFlags:
  -- Here we collect the settings of the language extensions
  -- from the command line, the ghci config file and
  -- from interactive :set / :seti commands.
  DynFlags -> [OnOff Extension]
extensions            :: [OnOff LangExt.Extension],
  -- extensionFlags should always be equal to
  --     flattenExtensionFlags language extensions
  -- LangExt.Extension is defined in libraries/ghc-boot so that it can be used
  -- by template-haskell
  DynFlags -> EnumSet Extension
extensionFlags        :: EnumSet LangExt.Extension,

  -- | Unfolding control
  -- See Note [Discounts and thresholds] in GHC.Core.Unfold
  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,

  -- | GHCi scripts specified by -ghci-script, in reverse order
  DynFlags -> [[Char]]
ghciScripts           :: [String],

  -- Output style options
  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,

  -- | what kind of {-# SCC #-} to add automatically
  DynFlags -> ProfAuto
profAuto              :: ProfAuto,
  DynFlags -> [CallerCcFilter]
callerCcFilters       :: [CallerCcFilter],

  DynFlags -> Maybe [Char]
interactivePrint      :: Maybe String,

  -- | Machine dependent flags (-m\<blah> stuff)
  DynFlags -> Maybe SseVersion
sseVersion            :: Maybe SseVersion,
  DynFlags -> Maybe BmiVersion
bmiVersion            :: Maybe BmiVersion,
  DynFlags -> Bool
avx                   :: Bool,
  DynFlags -> Bool
avx2                  :: Bool,
  DynFlags -> Bool
avx512cd              :: Bool, -- Enable AVX-512 Conflict Detection Instructions.
  DynFlags -> Bool
avx512er              :: Bool, -- Enable AVX-512 Exponential and Reciprocal Instructions.
  DynFlags -> Bool
avx512f               :: Bool, -- Enable AVX-512 instructions.
  DynFlags -> Bool
avx512pf              :: Bool, -- Enable AVX-512 PreFetch Instructions.

  -- | Run-time linker information (what options we need, etc.)
  DynFlags -> IORef (Maybe LinkerInfo)
rtldInfo              :: IORef (Maybe LinkerInfo),

  -- | Run-time C compiler information
  DynFlags -> IORef (Maybe CompilerInfo)
rtccInfo              :: IORef (Maybe CompilerInfo),

  -- | Run-time assembler information
  DynFlags -> IORef (Maybe CompilerInfo)
rtasmInfo              :: IORef (Maybe CompilerInfo),

  -- Constants used to control the amount of optimization done.

  -- | Max size, in bytes, of inline array allocations.
  DynFlags -> Int
maxInlineAllocSize    :: Int,

  -- | Only inline memcpy if it generates no more than this many
  -- pseudo (roughly: Cmm) instructions.
  DynFlags -> Int
maxInlineMemcpyInsns  :: Int,

  -- | Only inline memset if it generates no more than this many
  -- pseudo (roughly: Cmm) instructions.
  DynFlags -> Int
maxInlineMemsetInsns  :: Int,

  -- | Reverse the order of error messages in GHC/GHCi
  DynFlags -> Bool
reverseErrors         :: Bool,

  -- | Limit the maximum number of errors to show
  DynFlags -> Maybe Int
maxErrors             :: Maybe Int,

  -- | Unique supply configuration for testing build determinism
  DynFlags -> Word
initialUnique         :: Word,
  DynFlags -> Int
uniqueIncrement       :: Int,
    -- 'Int' because it can be used to test uniques in decreasing order.

  -- | Temporary: CFG Edge weights for fast iterations
  DynFlags -> Weights
cfgWeights            :: Weights
}

{- Note [RHS Floating]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  We provide both 'Opt_LocalFloatOut' and 'Opt_LocalFloatOutTopLevel' to correspond to
  'doFloatFromRhs'; with this we can control floating out with GHC flags.

  This addresses https://gitlab.haskell.org/ghc/ghc/-/issues/13663 and
  allows for experimentation.
-}

class HasDynFlags m where
    getDynFlags :: m DynFlags

{- It would be desirable to have the more generalised

  instance (MonadTrans t, Monad m, HasDynFlags m) => HasDynFlags (t m) where
      getDynFlags = lift getDynFlags

instance definition. However, that definition would overlap with the
`HasDynFlags (GhcT m)` instance. Instead we define instances for a
couple of common Monad transformers explicitly. -}

instance (Monoid a, Monad m, HasDynFlags m) => HasDynFlags (WriterT a m) where
    getDynFlags :: WriterT a m DynFlags
getDynFlags = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags

instance (Monad m, HasDynFlags m) => HasDynFlags (ReaderT a m) where
    getDynFlags :: ReaderT a m DynFlags
getDynFlags = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags

instance (Monad m, HasDynFlags m) => HasDynFlags (MaybeT m) where
    getDynFlags :: MaybeT m DynFlags
getDynFlags = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags

instance (Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m) where
    getDynFlags :: ExceptT e m DynFlags
getDynFlags = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift forall (m :: * -> *). HasDynFlags m => m DynFlags
getDynFlags

class ContainsDynFlags t where
    extractDynFlags :: t -> DynFlags

-----------------------------------------------------------------------------
-- Accessors from 'DynFlags'

-- | "unbuild" a 'Settings' from a 'DynFlags'. This shouldn't be needed in the
-- vast majority of code. But GHCi questionably uses this to produce a default
-- 'DynFlags' from which to compute a flags diff for printing.
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 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 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 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 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 forall a b. (a -> b) -> a -> b
$ DynFlags -> FileSettings
fileSettings DynFlags
dflags
extraGccViaCFlags     :: DynFlags -> [String]
extraGccViaCFlags :: DynFlags -> [[Char]]
extraGccViaCFlags DynFlags
dflags = ToolSettings -> [[Char]]
toolSettings_extraGccViaCFlags 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_P                 :: DynFlags -> [String]
opt_P :: DynFlags -> [[Char]]
opt_P DynFlags
dflags = 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)
            forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_P (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)

-- This function packages everything that's needed to fingerprint opt_P
-- flags. See Note [Repeated -optP hashing].
opt_P_signature       :: DynFlags -> ([String], Fingerprint)
opt_P_signature :: DynFlags -> ([[Char]], Fingerprint)
opt_P_signature DynFlags
dflags =
  ( 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 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 forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_c                 :: DynFlags -> [String]
opt_c :: DynFlags -> [[Char]]
opt_c DynFlags
dflags = 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)
            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 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 forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_l                 :: DynFlags -> [String]
opt_l :: DynFlags -> [[Char]]
opt_l DynFlags
dflags = 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)
            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 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 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 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 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 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 forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags

-- | The directory for this version of ghc in the user's app directory
-- The appdir used to be in ~/.ghc but to respect the XDG specification
-- we want to move it under $XDG_DATA_HOME/
-- However, old tooling (like cabal) might still write package environments
-- to the old directory, so we prefer that if a subdirectory of ~/.ghc
-- with the correct target and GHC version suffix exists.
--
-- i.e. if ~/.ghc/$UNIQUE_SUBDIR exists we use that
-- otherwise we use $XDG_DATA_HOME/$UNIQUE_SUBDIR
--
-- UNIQUE_SUBDIR is typically a combination of the target platform and GHC version
versionedAppDir :: String -> ArchOS -> MaybeT IO FilePath
versionedAppDir :: [Char] -> ArchOS -> MaybeT IO [Char]
versionedAppDir [Char]
appname ArchOS
platform = do
  -- Make sure we handle the case the HOME isn't set (see #11678)
  -- We need to fallback to the old scheme if the subdirectory exists.
  forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, MonadPlus m) =>
t (m a) -> m a
msum forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map ([Char] -> MaybeT IO [Char]
checkIfExists forall (m :: * -> *) b c a.
Monad m =>
(b -> m c) -> (a -> m b) -> a -> m c
<=< forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ([Char] -> ShowS
</> ArchOS -> [Char]
versionedFilePath ArchOS
platform))
       [ forall a. IO a -> MaybeT IO a
tryMaybeT forall a b. (a -> b) -> a -> b
$ [Char] -> IO [Char]
getAppUserDataDirectory [Char]
appname  -- this is ~/.ghc/
       , forall a. IO a -> MaybeT IO a
tryMaybeT forall a b. (a -> b) -> a -> b
$ XdgDirectory -> [Char] -> IO [Char]
getXdgDirectory XdgDirectory
XdgData [Char]
appname -- this is $XDG_DATA_HOME/
       ]
  where
    checkIfExists :: [Char] -> MaybeT IO [Char]
checkIfExists [Char]
dir = forall a. IO a -> MaybeT IO a
tryMaybeT ([Char] -> IO Bool
doesDirectoryExist [Char]
dir) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \case
      Bool
True -> forall (f :: * -> *) a. Applicative f => a -> f a
pure [Char]
dir
      Bool
False -> forall (m :: * -> *) a. m (Maybe a) -> MaybeT m a
MaybeT (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing)

versionedFilePath :: ArchOS -> FilePath
versionedFilePath :: ArchOS -> [Char]
versionedFilePath ArchOS
platform = ArchOS -> [Char]
uniqueSubdir ArchOS
platform

-- | The 'GhcMode' tells us whether we're doing multi-module
-- compilation (controlled via the "GHC" API) or one-shot
-- (single-module) compilation.  This makes a difference primarily to
-- the "GHC.Unit.Finder": in one-shot mode we look for interface files for
-- imported modules, but in multi-module mode we look for source files
-- in order to check whether they need to be recompiled.
data GhcMode
  = CompManager         -- ^ @\-\-make@, GHCi, etc.
  | OneShot             -- ^ @ghc -c Foo.hs@
  | MkDepend            -- ^ @ghc -M@, see "GHC.Unit.Finder" for why we need this
  deriving GhcMode -> GhcMode -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GhcMode -> GhcMode -> Bool
$c/= :: GhcMode -> GhcMode -> Bool
== :: GhcMode -> GhcMode -> Bool
$c== :: GhcMode -> GhcMode -> Bool
Eq

instance Outputable GhcMode where
  ppr :: GhcMode -> SDoc
ppr GhcMode
CompManager = forall doc. IsLine doc => [Char] -> doc
text [Char]
"CompManager"
  ppr GhcMode
OneShot     = forall doc. IsLine doc => [Char] -> doc
text [Char]
"OneShot"
  ppr GhcMode
MkDepend    = forall doc. IsLine doc => [Char] -> doc
text [Char]
"MkDepend"

isOneShot :: GhcMode -> Bool
isOneShot :: GhcMode -> Bool
isOneShot GhcMode
OneShot = Bool
True
isOneShot GhcMode
_other  = Bool
False

-- | What to do in the link step, if there is one.
data GhcLink
  = NoLink              -- ^ Don't link at all
  | LinkBinary          -- ^ Link object code into a binary
  | LinkInMemory        -- ^ Use the in-memory dynamic linker (works for both
                        --   bytecode and object code).
  | LinkDynLib          -- ^ Link objects into a dynamic lib (DLL on Windows, DSO on ELF platforms)
  | LinkStaticLib       -- ^ Link objects into a static lib
  | LinkMergedObj       -- ^ Link objects into a merged "GHCi object"
  deriving (GhcLink -> GhcLink -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GhcLink -> GhcLink -> Bool
$c/= :: GhcLink -> GhcLink -> Bool
== :: GhcLink -> GhcLink -> Bool
$c== :: GhcLink -> GhcLink -> Bool
Eq, Int -> GhcLink -> ShowS
[GhcLink] -> ShowS
GhcLink -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [GhcLink] -> ShowS
$cshowList :: [GhcLink] -> ShowS
show :: GhcLink -> [Char]
$cshow :: GhcLink -> [Char]
showsPrec :: Int -> GhcLink -> ShowS
$cshowsPrec :: Int -> GhcLink -> ShowS
Show)

isNoLink :: GhcLink -> Bool
isNoLink :: GhcLink -> Bool
isNoLink GhcLink
NoLink = Bool
True
isNoLink GhcLink
_      = Bool
False

-- | We accept flags which make packages visible, but how they select
-- the package varies; this data type reflects what selection criterion
-- is used.
data PackageArg =
      PackageArg String    -- ^ @-package@, by 'PackageName'
    | UnitIdArg Unit       -- ^ @-package-id@, by 'Unit'
  deriving (PackageArg -> PackageArg -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageArg -> PackageArg -> Bool
$c/= :: PackageArg -> PackageArg -> Bool
== :: PackageArg -> PackageArg -> Bool
$c== :: PackageArg -> PackageArg -> Bool
Eq, Int -> PackageArg -> ShowS
[PackageArg] -> ShowS
PackageArg -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [PackageArg] -> ShowS
$cshowList :: [PackageArg] -> ShowS
show :: PackageArg -> [Char]
$cshow :: PackageArg -> [Char]
showsPrec :: Int -> PackageArg -> ShowS
$cshowsPrec :: Int -> PackageArg -> ShowS
Show)

instance Outputable PackageArg where
    ppr :: PackageArg -> SDoc
ppr (PackageArg [Char]
pn) = forall doc. IsLine doc => [Char] -> doc
text [Char]
"package" forall doc. IsLine doc => doc -> doc -> doc
<+> forall doc. IsLine doc => [Char] -> doc
text [Char]
pn
    ppr (UnitIdArg Unit
uid) = forall doc. IsLine doc => [Char] -> doc
text [Char]
"unit" forall doc. IsLine doc => doc -> doc -> doc
<+> forall a. Outputable a => a -> SDoc
ppr Unit
uid

-- | Represents the renaming that may be associated with an exposed
-- package, e.g. the @rns@ part of @-package "foo (rns)"@.
--
-- Here are some example parsings of the package flags (where
-- a string literal is punned to be a 'ModuleName':
--
--      * @-package foo@ is @ModRenaming True []@
--      * @-package foo ()@ is @ModRenaming False []@
--      * @-package foo (A)@ is @ModRenaming False [("A", "A")]@
--      * @-package foo (A as B)@ is @ModRenaming False [("A", "B")]@
--      * @-package foo with (A as B)@ is @ModRenaming True [("A", "B")]@
data ModRenaming = ModRenaming {
    ModRenaming -> Bool
modRenamingWithImplicit :: Bool, -- ^ Bring all exposed modules into scope?
    ModRenaming -> [(ModuleName, ModuleName)]
modRenamings :: [(ModuleName, ModuleName)] -- ^ Bring module @m@ into scope
                                               --   under name @n@.
  } deriving (ModRenaming -> ModRenaming -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModRenaming -> ModRenaming -> Bool
$c/= :: ModRenaming -> ModRenaming -> Bool
== :: ModRenaming -> ModRenaming -> Bool
$c== :: ModRenaming -> ModRenaming -> Bool
Eq)
instance Outputable ModRenaming where
    ppr :: ModRenaming -> SDoc
ppr (ModRenaming Bool
b [(ModuleName, ModuleName)]
rns) = forall a. Outputable a => a -> SDoc
ppr Bool
b forall doc. IsLine doc => doc -> doc -> doc
<+> forall doc. IsLine doc => doc -> doc
parens (forall a. Outputable a => a -> SDoc
ppr [(ModuleName, ModuleName)]
rns)

-- | Flags for manipulating the set of non-broken packages.
newtype IgnorePackageFlag = IgnorePackage String -- ^ @-ignore-package@
  deriving (IgnorePackageFlag -> IgnorePackageFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
$c/= :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
== :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
$c== :: IgnorePackageFlag -> IgnorePackageFlag -> Bool
Eq)

-- | Flags for manipulating package trust.
data TrustFlag
  = TrustPackage    String -- ^ @-trust@
  | DistrustPackage String -- ^ @-distrust@
  deriving (TrustFlag -> TrustFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TrustFlag -> TrustFlag -> Bool
$c/= :: TrustFlag -> TrustFlag -> Bool
== :: TrustFlag -> TrustFlag -> Bool
$c== :: TrustFlag -> TrustFlag -> Bool
Eq)

-- | Flags for manipulating packages visibility.
data PackageFlag
  = ExposePackage   String PackageArg ModRenaming -- ^ @-package@, @-package-id@
  | HidePackage     String -- ^ @-hide-package@
  deriving (PackageFlag -> PackageFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageFlag -> PackageFlag -> Bool
$c/= :: PackageFlag -> PackageFlag -> Bool
== :: PackageFlag -> PackageFlag -> Bool
$c== :: PackageFlag -> PackageFlag -> Bool
Eq) -- NB: equality instance is used by packageFlagsChanged

data PackageDBFlag
  = PackageDB PkgDbRef
  | NoUserPackageDB
  | NoGlobalPackageDB
  | ClearPackageDBs
  deriving (PackageDBFlag -> PackageDBFlag -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PackageDBFlag -> PackageDBFlag -> Bool
$c/= :: PackageDBFlag -> PackageDBFlag -> Bool
== :: PackageDBFlag -> PackageDBFlag -> Bool
$c== :: PackageDBFlag -> PackageDBFlag -> Bool
Eq)

packageFlagsChanged :: DynFlags -> DynFlags -> Bool
packageFlagsChanged :: DynFlags -> DynFlags -> Bool
packageFlagsChanged DynFlags
idflags1 DynFlags
idflags0 =
  DynFlags -> [PackageFlag]
packageFlags DynFlags
idflags1 forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageFlag]
packageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
idflags1 forall a. Eq a => a -> a -> Bool
/= DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
idflags1 forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [TrustFlag]
trustFlags DynFlags
idflags1 forall a. Eq a => a -> a -> Bool
/= DynFlags -> [TrustFlag]
trustFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
idflags1 forall a. Eq a => a -> a -> Bool
/= DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
idflags0 Bool -> Bool -> Bool
||
  DynFlags -> [Bool]
packageGFlags DynFlags
idflags1 forall a. Eq a => a -> a -> Bool
/= DynFlags -> [Bool]
packageGFlags DynFlags
idflags0
 where
   packageGFlags :: DynFlags -> [Bool]
packageGFlags DynFlags
dflags = 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) = forall doc. IsLine doc => [Char] -> doc
text [Char]
n forall doc. IsLine doc => doc -> doc -> doc
<> forall doc. IsLine doc => doc -> doc
braces (forall a. Outputable a => a -> SDoc
ppr PackageArg
arg forall doc. IsLine doc => doc -> doc -> doc
<+> forall a. Outputable a => a -> SDoc
ppr ModRenaming
rn)
    ppr (HidePackage [Char]
str) = forall doc. IsLine doc => [Char] -> doc
text [Char]
"-hide-package" forall doc. IsLine doc => doc -> doc -> doc
<+> forall doc. IsLine doc => [Char] -> doc
text [Char]
str

data DynLibLoader
  = Deployable
  | SystemDependent
  deriving DynLibLoader -> DynLibLoader -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DynLibLoader -> DynLibLoader -> Bool
$c/= :: DynLibLoader -> DynLibLoader -> Bool
== :: DynLibLoader -> DynLibLoader -> Bool
$c== :: DynLibLoader -> DynLibLoader -> Bool
Eq

data RtsOptsEnabled
  = RtsOptsNone | RtsOptsIgnore | RtsOptsIgnoreAll | RtsOptsSafeOnly
  | RtsOptsAll
  deriving (Int -> RtsOptsEnabled -> ShowS
[RtsOptsEnabled] -> ShowS
RtsOptsEnabled -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [RtsOptsEnabled] -> ShowS
$cshowList :: [RtsOptsEnabled] -> ShowS
show :: RtsOptsEnabled -> [Char]
$cshow :: RtsOptsEnabled -> [Char]
showsPrec :: Int -> RtsOptsEnabled -> ShowS
$cshowsPrec :: Int -> RtsOptsEnabled -> ShowS
Show)

-- | Are we building with @-fPIE@ or @-fPIC@ enabled?
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

-- Note [-dynamic-too business]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- With -dynamic-too flag, we try to build both the non-dynamic and dynamic
-- objects in a single run of the compiler: the pipeline is the same down to
-- Core optimisation, then the backend (from Core to object code) is executed
-- twice.
--
-- The implementation is currently rather hacky, for example, we don't clearly separate non-dynamic
-- and dynamic loaded interfaces (#9176).
--
-- To make matters worse, we automatically enable -dynamic-too when some modules
-- need Template-Haskell and GHC is dynamically linked (cf
-- GHC.Driver.Pipeline.compileOne').
--
-- We used to try and fall back from a dynamic-too failure but this feature
-- didn't work as expected (#20446) so it was removed to simplify the
-- implementation and not obscure latent bugs.

data DynamicTooState
   = DT_Dont    -- ^ Don't try to build dynamic objects too
   | DT_OK      -- ^ Will still try to generate dynamic objects
   | DT_Dyn     -- ^ Currently generating dynamic objects (in the backend)
   deriving (DynamicTooState -> DynamicTooState -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: DynamicTooState -> DynamicTooState -> Bool
$c/= :: DynamicTooState -> DynamicTooState -> Bool
== :: DynamicTooState -> DynamicTooState -> Bool
$c== :: DynamicTooState -> DynamicTooState -> Bool
Eq,Int -> DynamicTooState -> ShowS
[DynamicTooState] -> ShowS
DynamicTooState -> [Char]
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
showList :: [DynamicTooState] -> ShowS
$cshowList :: [DynamicTooState] -> ShowS
show :: DynamicTooState -> [Char]
$cshow :: DynamicTooState -> [Char]
showsPrec :: Int -> DynamicTooState -> ShowS
$cshowsPrec :: Int -> DynamicTooState -> ShowS
Show,Eq 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
min :: DynamicTooState -> DynamicTooState -> DynamicTooState
$cmin :: DynamicTooState -> DynamicTooState -> DynamicTooState
max :: DynamicTooState -> DynamicTooState -> DynamicTooState
$cmax :: DynamicTooState -> DynamicTooState -> DynamicTooState
>= :: DynamicTooState -> DynamicTooState -> Bool
$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
compare :: DynamicTooState -> DynamicTooState -> Ordering
$ccompare :: DynamicTooState -> DynamicTooState -> Ordering
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
      }

-----------------------------------------------------------------------------

-- | Used by 'GHC.runGhc' to partially initialize a new 'DynFlags' value
initDynFlags :: DynFlags -> IO DynFlags
initDynFlags :: DynFlags -> IO DynFlags
initDynFlags DynFlags
dflags = do
 let
 IORef (Maybe LinkerInfo)
refRtldInfo <- forall a. a -> IO (IORef a)
newIORef forall a. Maybe a
Nothing
 IORef (Maybe CompilerInfo)
refRtccInfo <- forall a. a -> IO (IORef a)
newIORef forall a. Maybe a
Nothing
 IORef (Maybe CompilerInfo)
refRtasmInfo <- forall a. a -> IO (IORef a)
newIORef forall a. Maybe a
Nothing
 Bool
canUseUnicode <- do let enc :: TextEncoding
enc = TextEncoding
localeEncoding
                         str :: [Char]
str = [Char]
"‘’"
                     (forall a. TextEncoding -> [Char] -> (CString -> IO a) -> IO a
withCString TextEncoding
enc [Char]
str forall a b. (a -> b) -> a -> b
$ \CString
cstr ->
                          do [Char]
str' <- TextEncoding -> CString -> IO [Char]
peekCString TextEncoding
enc CString
cstr
                             forall (m :: * -> *) a. Monad m => a -> m a
return ([Char]
str forall a. Eq a => a -> a -> Bool
== [Char]
str'))
                         forall a. IO a -> (IOError -> IO a) -> IO a
`catchIOError` \IOError
_ -> 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' = 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    = forall a. a -> a
id
 let (OverridingBool
useColor', Scheme
colScheme') =
       (Maybe [Char]
-> (OverridingBool, Scheme) -> (OverridingBool, Scheme)
adjustCols Maybe [Char]
maybeGhcColoursEnv 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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO [Char]
getTemporaryDirectory
 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
        }

-- | The normal 'DynFlags'. Note that they are not suitable for use in this form
-- and must be fully initialized by 'GHC.runGhc' first.
defaultDynFlags :: Settings -> DynFlags
defaultDynFlags :: Settings -> DynFlags
defaultDynFlags Settings
mySettings =
-- See Note [Updating flag description in the User's Guide]
     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               = forall a. Maybe a
Nothing,
        binBlobThreshold :: Maybe Word
binBlobThreshold        = forall a. a -> Maybe a
Just Word
500000, -- 500K is a good default (see #16190)
        maxRelevantBinds :: Maybe Int
maxRelevantBinds        = forall a. a -> Maybe a
Just Int
6,
        maxValidHoleFits :: Maybe Int
maxValidHoleFits   = forall a. a -> Maybe a
Just Int
6,
        maxRefHoleFits :: Maybe Int
maxRefHoleFits     = forall a. a -> Maybe a
Just Int
6,
        refLevelHoleFits :: Maybe Int
refLevelHoleFits   = 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,      -- Default: Assume an unboxed demand on function bodies returning a triple
        specConstrThreshold :: Maybe Int
specConstrThreshold     = forall a. a -> Maybe a
Just Int
2000,
        specConstrCount :: Maybe Int
specConstrCount         = forall a. a -> Maybe a
Just Int
3,
        specConstrRecursive :: Int
specConstrRecursive     = Int
3,
        liberateCaseThreshold :: Maybe Int
liberateCaseThreshold   = forall a. a -> Maybe a
Just Int
2000,
        floatLamArgs :: Maybe Int
floatLamArgs            = forall a. a -> Maybe a
Just Int
0, -- Default: float only if no fvs
        liftLamsRecArgs :: Maybe Int
liftLamsRecArgs         = forall a. a -> Maybe a
Just Int
5, -- Default: the number of available argument hardware registers on x86_64
        liftLamsNonRecArgs :: Maybe Int
liftLamsNonRecArgs      = forall a. a -> Maybe a
Just Int
5, -- Default: the number of available argument hardware registers on x86_64
        liftLamsKnown :: Bool
liftLamsKnown           = Bool
False,  -- Default: don't turn known calls into unknown ones
        cmmProcAlignment :: Maybe Int
cmmProcAlignment        = forall a. Maybe a
Nothing,

        historySize :: Int
historySize             = Int
20,
        strictnessBefore :: [Int]
strictnessBefore        = [],

        parMakeCount :: Maybe Int
parMakeCount            = forall a. a -> Maybe a
Just Int
1,

        enableTimeStats :: Bool
enableTimeStats         = Bool
False,
        ghcHeapSize :: Maybe Int
ghcHeapSize             = forall a. Maybe a
Nothing,

        importPaths :: [[Char]]
importPaths             = [[Char]
"."],
        mainModuleNameIs :: ModuleName
mainModuleNameIs        = ModuleName
mAIN_NAME,
        mainFunIs :: Maybe [Char]
mainFunIs               = 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_     = forall a. Maybe a
Nothing,
        homeUnitInstantiations_ :: [(ModuleName, Module)]
homeUnitInstantiations_ = [],

        workingDirectory :: Maybe [Char]
workingDirectory        = forall a. Maybe a
Nothing,
        thisPackageName :: Maybe [Char]
thisPackageName         = forall a. Maybe a
Nothing,
        hiddenModules :: Set ModuleName
hiddenModules           = forall a. Set a
Set.empty,
        reexportedModules :: Set ModuleName
reexportedModules       = forall a. Set a
Set.empty,

        objectDir :: Maybe [Char]
objectDir               = forall a. Maybe a
Nothing,
        dylibInstallName :: Maybe [Char]
dylibInstallName        = forall a. Maybe a
Nothing,
        hiDir :: Maybe [Char]
hiDir                   = forall a. Maybe a
Nothing,
        hieDir :: Maybe [Char]
hieDir                  = forall a. Maybe a
Nothing,
        stubDir :: Maybe [Char]
stubDir                 = forall a. Maybe a
Nothing,
        dumpDir :: Maybe [Char]
dumpDir                 = 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_" 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      = [],

        externalPluginSpecs :: [ExternalPluginSpec]
externalPluginSpecs     = [],

        outputFile_ :: Maybe [Char]
outputFile_             = forall a. Maybe a
Nothing,
        dynOutputFile_ :: Maybe [Char]
dynOutputFile_          = forall a. Maybe a
Nothing,
        outputHi :: Maybe [Char]
outputHi                = forall a. Maybe a
Nothing,
        dynOutputHi :: Maybe [Char]
dynOutputHi             = forall a. Maybe a
Nothing,
        dynLibLoader :: DynLibLoader
dynLibLoader            = DynLibLoader
SystemDependent,
        dumpPrefix :: [Char]
dumpPrefix              = [Char]
"non-module.",
        dumpPrefixForce :: Maybe [Char]
dumpPrefixForce         = 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                 = 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              = forall a. Maybe a
Nothing,
        targetWays_ :: Ways
targetWays_             = forall a. Set a
Set.empty,
        splitInfo :: Maybe ([Char], Int)
splitInfo               = 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                  = forall a. HasCallStack => [Char] -> a
panic [Char]
"defaultDynFlags: uninitialized tmpDir",

        llvmOptLevel :: Int
llvmOptLevel            = Int
0,

        -- ghc -M values
        depMakefile :: [Char]
depMakefile       = [Char]
"Makefile",
        depIncludePkgDeps :: Bool
depIncludePkgDeps = Bool
False,
        depIncludeCppDeps :: Bool
depIncludeCppDeps = Bool
False,
        depExcludeMods :: [ModuleName]
depExcludeMods    = [],
        depSuffixes :: [[Char]]
depSuffixes       = [],
        -- end of ghc -M values
        ghcVersionFile :: Maybe [Char]
ghcVersionFile = forall a. Maybe a
Nothing,
        haddockOptions :: Maybe [Char]
haddockOptions = forall a. Maybe a
Nothing,
        dumpFlags :: EnumSet DumpFlag
dumpFlags = forall a. EnumSet a
EnumSet.empty,
        generalFlags :: EnumSet GeneralFlag
generalFlags = forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList (Settings -> [GeneralFlag]
defaultFlags Settings
mySettings),
        warningFlags :: EnumSet WarningFlag
warningFlags = forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList [WarningFlag]
standardWarnings,
        fatalWarningFlags :: EnumSet WarningFlag
fatalWarningFlags = forall a. EnumSet a
EnumSet.empty,
        ghciScripts :: [[Char]]
ghciScripts = [],
        language :: Maybe Language
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 forall a. Maybe a
Nothing [],

        unfoldingOpts :: UnfoldingOpts
unfoldingOpts = UnfoldingOpts
defaultUnfoldingOpts,
        maxWorkerArgs :: Int
maxWorkerArgs = Int
10,

        ghciHistSize :: Int
ghciHistSize = Int
50, -- keep a log of length 50 by default

        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 = forall a. Maybe a
Nothing,
        sseVersion :: Maybe SseVersion
sseVersion = forall a. Maybe a
Nothing,
        bmiVersion :: Maybe BmiVersion
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 = forall a. HasCallStack => [Char] -> a
panic [Char]
"defaultDynFlags: no rtldInfo",
        rtccInfo :: IORef (Maybe CompilerInfo)
rtccInfo = forall a. HasCallStack => [Char] -> a
panic [Char]
"defaultDynFlags: no rtccInfo",
        rtasmInfo :: IORef (Maybe CompilerInfo)
rtasmInfo = forall a. HasCallStack => [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     = 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 forall a b. (a -> b) -> a -> b
$ Handle -> IO ()
hFlush Handle
stdout

{-
Note [Verbosity levels]
~~~~~~~~~~~~~~~~~~~~~~~
    0   |   print errors & warnings only
    1   |   minimal verbosity: print "compiling M ... done." for each module.
    2   |   equivalent to -dshow-passes
    3   |   equivalent to existing "ghc -v"
    4   |   "ghc -v -ddump-most"
    5   |   "ghc -v -ddump-all"
-}

data OnOff a = On a
             | Off a
  deriving (OnOff a -> OnOff a -> Bool
forall a. Eq a => OnOff a -> OnOff a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OnOff a -> OnOff a -> Bool
$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
Eq, Int -> OnOff a -> ShowS
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
showList :: [OnOff a] -> ShowS
$cshowList :: forall a. Show a => [OnOff a] -> ShowS
show :: OnOff a -> [Char]
$cshow :: forall a. Show a => OnOff a -> [Char]
showsPrec :: Int -> OnOff a -> ShowS
$cshowsPrec :: forall a. Show a => Int -> OnOff a -> ShowS
Show)

instance Outputable a => Outputable (OnOff a) where
  ppr :: OnOff a -> SDoc
ppr (On a
x)  = forall doc. IsLine doc => [Char] -> doc
text [Char]
"On" forall doc. IsLine doc => doc -> doc -> doc
<+> forall a. Outputable a => a -> SDoc
ppr a
x
  ppr (Off a
x) = forall doc. IsLine doc => [Char] -> doc
text [Char]
"Off" forall doc. IsLine doc => doc -> doc -> doc
<+> forall a. Outputable a => a -> SDoc
ppr a
x

-- OnOffs accumulate in reverse order, so we use foldr in order to
-- process them in the right order
flattenExtensionFlags :: Maybe Language -> [OnOff LangExt.Extension] -> EnumSet LangExt.Extension
flattenExtensionFlags :: Maybe Language -> [OnOff Extension] -> EnumSet Extension
flattenExtensionFlags Maybe Language
ml = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr 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 = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert a
f EnumSet a
flags
          f (Off a
f) EnumSet a
flags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete a
f EnumSet a
flags
          defaultExtensionFlags :: EnumSet Extension
defaultExtensionFlags = forall a. Enum a => [a] -> EnumSet a
EnumSet.fromList (Maybe Language -> [Extension]
languageExtensions Maybe Language
ml)

-- | The language extensions implied by the various language variants.
-- When updating this be sure to update the flag documentation in
-- @docs/users_guide/exts@.
languageExtensions :: Maybe Language -> [LangExt.Extension]

-- Nothing: the default case
languageExtensions :: Maybe Language -> [Extension]
languageExtensions Maybe Language
Nothing = Maybe Language -> [Extension]
languageExtensions (forall a. a -> Maybe a
Just Language
GHC2021)

languageExtensions (Just Language
Haskell98)
    = [Extension
LangExt.ImplicitPrelude,
       -- See Note [When is StarIsType enabled]
       Extension
LangExt.StarIsType,
       Extension
LangExt.CUSKs,
       Extension
LangExt.MonomorphismRestriction,
       Extension
LangExt.NPlusKPatterns,
       Extension
LangExt.DatatypeContexts,
       Extension
LangExt.TraditionalRecordSyntax,
       Extension
LangExt.FieldSelectors,
       Extension
LangExt.NondecreasingIndentation,
           -- strictly speaking non-standard, but we always had this
           -- on implicitly before the option was added in 7.1, and
           -- turning it off breaks code, so we're keeping it on for
           -- backwards compatibility.  Cabal uses -XHaskell98 by
           -- default unless you specify another language.
       Extension
LangExt.DeepSubsumption
       -- Non-standard but enabled for backwards compatability (see GHC proposal #511)
      ]

languageExtensions (Just Language
Haskell2010)
    = [Extension
LangExt.ImplicitPrelude,
       -- See Note [When is StarIsType enabled]
       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,
       -- See Note [When is StarIsType enabled]
       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,
       -- Now the new extensions (not in Haskell2010)
       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


-- | Test whether a 'DumpFlag' is set
dopt :: DumpFlag -> DynFlags -> Bool
dopt :: DumpFlag -> DynFlags -> Bool
dopt = forall a.
(a -> Int) -> (a -> EnumSet DumpFlag) -> DumpFlag -> a -> Bool
getDumpFlagFrom DynFlags -> Int
verbosity DynFlags -> EnumSet DumpFlag
dumpFlags

-- | Set a 'DumpFlag'
dopt_set :: DynFlags -> DumpFlag -> DynFlags
dopt_set :: DynFlags -> DumpFlag -> DynFlags
dopt_set DynFlags
dfs DumpFlag
f = DynFlags
dfs{ dumpFlags :: EnumSet DumpFlag
dumpFlags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert DumpFlag
f (DynFlags -> EnumSet DumpFlag
dumpFlags DynFlags
dfs) }

-- | Unset a 'DumpFlag'
dopt_unset :: DynFlags -> DumpFlag -> DynFlags
dopt_unset :: DynFlags -> DumpFlag -> DynFlags
dopt_unset DynFlags
dfs DumpFlag
f = DynFlags
dfs{ dumpFlags :: EnumSet DumpFlag
dumpFlags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete DumpFlag
f (DynFlags -> EnumSet DumpFlag
dumpFlags DynFlags
dfs) }

-- | Test whether a 'GeneralFlag' is set
--
-- Note that `dynamicNow` (i.e., dynamic objects built with `-dynamic-too`)
-- always implicitly enables Opt_PIC, Opt_ExternalDynamicRefs, and disables
-- Opt_SplitSections.
--
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 forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dflags

-- | Set a 'GeneralFlag'
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt_set :: DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dfs GeneralFlag
f = DynFlags
dfs{ generalFlags :: EnumSet GeneralFlag
generalFlags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert GeneralFlag
f (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dfs) }

-- | Unset a 'GeneralFlag'
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
gopt_unset :: DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dfs GeneralFlag
f = DynFlags
dfs{ generalFlags :: EnumSet GeneralFlag
generalFlags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete GeneralFlag
f (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
dfs) }

-- | Test whether a 'WarningFlag' is set
wopt :: WarningFlag -> DynFlags -> Bool
wopt :: WarningFlag -> DynFlags -> Bool
wopt WarningFlag
f DynFlags
dflags  = WarningFlag
f forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet WarningFlag
warningFlags DynFlags
dflags

-- | Set a 'WarningFlag'
wopt_set :: DynFlags -> WarningFlag -> DynFlags
wopt_set :: DynFlags -> WarningFlag -> DynFlags
wopt_set DynFlags
dfs WarningFlag
f = DynFlags
dfs{ warningFlags :: EnumSet WarningFlag
warningFlags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert WarningFlag
f (DynFlags -> EnumSet WarningFlag
warningFlags DynFlags
dfs) }

-- | Unset a 'WarningFlag'
wopt_unset :: DynFlags -> WarningFlag -> DynFlags
wopt_unset :: DynFlags -> WarningFlag -> DynFlags
wopt_unset DynFlags
dfs WarningFlag
f = DynFlags
dfs{ warningFlags :: EnumSet WarningFlag
warningFlags = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete WarningFlag
f (DynFlags -> EnumSet WarningFlag
warningFlags DynFlags
dfs) }

-- | Test whether a 'WarningFlag' is set as fatal
wopt_fatal :: WarningFlag -> DynFlags -> Bool
wopt_fatal :: WarningFlag -> DynFlags -> Bool
wopt_fatal WarningFlag
f DynFlags
dflags = WarningFlag
f forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dflags

-- | Mark a 'WarningFlag' as fatal (do not set the flag)
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 = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.insert WarningFlag
f (DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dfs) }

-- | Mark a 'WarningFlag' as not fatal
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 = forall a. Enum a => a -> EnumSet a -> EnumSet a
EnumSet.delete WarningFlag
f (DynFlags -> EnumSet WarningFlag
fatalWarningFlags DynFlags
dfs) }

-- | Test whether a 'LangExt.Extension' is set
xopt :: LangExt.Extension -> DynFlags -> Bool
xopt :: Extension -> DynFlags -> Bool
xopt Extension
f DynFlags
dflags = Extension
f forall a. Enum a => a -> EnumSet a -> Bool
`EnumSet.member` DynFlags -> EnumSet Extension
extensionFlags DynFlags
dflags

-- | Set a 'LangExt.Extension'
xopt_set :: DynFlags -> LangExt.Extension -> DynFlags
xopt_set :: DynFlags -> Extension -> DynFlags
xopt_set DynFlags
dfs Extension
f
    = let onoffs :: [OnOff Extension]
onoffs = forall a. a -> OnOff a
On Extension
f 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 }

-- | Unset a 'LangExt.Extension'
xopt_unset :: DynFlags -> LangExt.Extension -> DynFlags
xopt_unset :: DynFlags -> Extension -> DynFlags
xopt_unset DynFlags
dfs Extension
f
    = let onoffs :: [OnOff Extension]
onoffs = forall a. a -> OnOff a
Off Extension
f 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 }

-- | Set or unset a 'LangExt.Extension', unless it has been explicitly
--   set or unset before.
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 = forall {a}. OnOff a -> a
stripOnOff 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 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)
          }

-- | Set the Haskell language standard to use
setLanguage :: Language -> DynP ()
setLanguage :: Language -> DynP ()
setLanguage Language
l = (DynFlags -> DynFlags) -> DynP ()
upd (DynFlags -> Maybe Language -> DynFlags
`lang_set` forall a. a -> Maybe a
Just Language
l)

-- | Is the -fpackage-trust mode on
packageTrustOn :: DynFlags -> Bool
packageTrustOn :: DynFlags -> Bool
packageTrustOn = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PackageTrust

-- | Is Safe Haskell on in some way (including inference mode)
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 forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [SafeHaskellMode
Sf_Unsafe, SafeHaskellMode
Sf_Trustworthy
                                                   , SafeHaskellMode
Sf_Safe ]


-- | Is the Safe Haskell safe language in use
safeLanguageOn :: DynFlags -> Bool
safeLanguageOn :: DynFlags -> Bool
safeLanguageOn DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Safe

-- | Is the Safe Haskell safe inference mode active
safeInferOn :: DynFlags -> Bool
safeInferOn :: DynFlags -> Bool
safeInferOn = DynFlags -> Bool
safeInfer

-- | Test if Safe Imports are on in some form
safeImportsOn :: DynFlags -> Bool
safeImportsOn :: DynFlags -> Bool
safeImportsOn DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Unsafe Bool -> Bool -> Bool
||
                       DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Trustworthy Bool -> Bool -> Bool
||
                       DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Safe

-- | Set a 'Safe Haskell' flag
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 -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM, safeInfer :: Bool
safeInfer = Bool
False }
                -- leave safe inference on in Trustworthy mode so we can warn
                -- if it could have been inferred safe.
                SafeHaskellMode
Sf_Trustworthy -> do
                  SrcSpan
l <- forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
                  forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM, trustworthyOnLoc :: SrcSpan
trustworthyOnLoc = SrcSpan
l }
                -- leave safe inference on in Unsafe mode as well.
                SafeHaskellMode
_ -> forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell :: SafeHaskellMode
safeHaskell = SafeHaskellMode
safeM }

-- | Are all direct imports required to be safe for this Safe Haskell mode?
-- Direct imports are when the code explicitly imports a module
safeDirectImpsReq :: DynFlags -> Bool
safeDirectImpsReq :: DynFlags -> Bool
safeDirectImpsReq DynFlags
d = DynFlags -> Bool
safeLanguageOn DynFlags
d

-- | Are all implicit imports required to be safe for this Safe Haskell mode?
-- Implicit imports are things in the prelude. e.g System.IO when print is used.
safeImplicitImpsReq :: DynFlags -> Bool
safeImplicitImpsReq :: DynFlags -> Bool
safeImplicitImpsReq DynFlags
d = DynFlags -> Bool
safeLanguageOn DynFlags
d

-- | Combine two Safe Haskell modes correctly. Used for dealing with multiple flags.
-- This makes Safe Haskell very much a monoid but for now I prefer this as I don't
-- want to export this functionality from the module but do want to export the
-- type constructors.
combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags :: SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags SafeHaskellMode
a SafeHaskellMode
b | SafeHaskellMode
a forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_None         = forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
b
                     | SafeHaskellMode
b forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_None         = forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
a
                     | SafeHaskellMode
a forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Ignore Bool -> Bool -> Bool
|| SafeHaskellMode
b forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
Sf_Ignore = forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
Sf_Ignore
                     | SafeHaskellMode
a forall a. Eq a => a -> a -> Bool
== SafeHaskellMode
b               = forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
a
                     | Bool
otherwise            = forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addErr [Char]
errm forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (f :: * -> *) a. Applicative f => a -> f a
pure SafeHaskellMode
a
    where errm :: [Char]
errm = [Char]
"Incompatible Safe Haskell flags! ("
                    forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show SafeHaskellMode
a forall a. [a] -> [a] -> [a]
++ [Char]
", " forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show SafeHaskellMode
b forall a. [a] -> [a] -> [a]
++ [Char]
")"

-- | A list of unsafe flags under Safe Haskell. Tuple elements are:
--     * name of the flag
--     * function to get srcspan that enabled the flag
--     * function to test if the flag is on
--     * function to turn the flag off
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,
                    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,
                    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,
                    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


-- | Retrieve the options corresponding to a particular @opt_*@ field in the correct order
getOpts :: DynFlags             -- ^ 'DynFlags' to retrieve the options from
        -> (DynFlags -> [a])    -- ^ Relevant record accessor: one of the @opt_*@ accessors
        -> [a]                  -- ^ Correctly ordered extracted options
getOpts :: forall a. DynFlags -> (DynFlags -> [a]) -> [a]
getOpts DynFlags
dflags DynFlags -> [a]
opts = forall a. [a] -> [a]
reverse (DynFlags -> [a]
opts DynFlags
dflags)
        -- We add to the options from the front, so we need to reverse the list

-- | Gets the verbosity flag for the current verbosity level. This is fed to
-- other tools, so GHC-specific verbosity flags like @-ddump-most@ are not included
getVerbFlags :: DynFlags -> [String]
getVerbFlags :: DynFlags -> [[Char]]
getVerbFlags DynFlags
dflags
  | DynFlags -> Int
verbosity DynFlags
dflags 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  = forall a. a -> Maybe a
Just [Char]
f}
setHiDir :: [Char] -> DynFlags -> DynFlags
setHiDir      [Char]
f DynFlags
d = DynFlags
d { hiDir :: Maybe [Char]
hiDir      = forall a. a -> Maybe a
Just [Char]
f}
setHieDir :: [Char] -> DynFlags -> DynFlags
setHieDir     [Char]
f DynFlags
d = DynFlags
d { hieDir :: Maybe [Char]
hieDir     = forall a. a -> Maybe a
Just [Char]
f}
setStubDir :: [Char] -> DynFlags -> DynFlags
setStubDir    [Char]
f DynFlags
d = DynFlags
d { stubDir :: Maybe [Char]
stubDir    = forall a. a -> Maybe a
Just [Char]
f
                      , includePaths :: IncludeSpecs
includePaths = IncludeSpecs -> [[Char]] -> IncludeSpecs
addGlobalInclude (DynFlags -> IncludeSpecs
includePaths DynFlags
d) [[Char]
f] }
  -- -stubdir D adds an implicit -I D, so that gcc can find the _stub.h file
  -- \#included from the .hc file when compiling via C (i.e. unregisterised
  -- builds).
setDumpDir :: [Char] -> DynFlags -> DynFlags
setDumpDir    [Char]
f DynFlags
d = DynFlags
d { dumpDir :: Maybe [Char]
dumpDir    = forall a. a -> Maybe a
Just [Char]
f}
setOutputDir :: [Char] -> DynFlags -> DynFlags
setOutputDir  [Char]
f = [Char] -> DynFlags -> DynFlags
setObjectDir [Char]
f
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setHieDir [Char]
f
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setHiDir [Char]
f
                forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setStubDir [Char]
f
                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 = 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 forall a. (a -> Bool) -> [a] -> [a]
filter ((forall a. Eq a => a -> a -> Bool
==[Char]
"")forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a b. (a, b) -> b
snd) (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])]
_ -> forall a. GhcException -> a
throwGhcException forall a b. (a -> b) -> a -> b
$ [Char] -> GhcException
CmdLineError ([Char]
"Can't parse -instantiated-with: " forall a. [a] -> [a] -> [a]
++ [Char]
str)
  where parse :: ReadP [(ModuleName, Module)]
parse = 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
            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_ = 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) 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) forall a. a -> [a] -> [a]
: (DynFlags -> [(ModuleName, [Char])]
pluginModNameOpts DynFlags
d) }
  where ([Char]
m, [Char]
rest) = forall a. (a -> Bool) -> [a] -> ([a], [a])
break (forall a. Eq a => a -> a -> Bool
== Char
':') [Char]
optflag
        option :: [Char]
option = case [Char]
rest of
          [] -> [Char]
"" -- should probably signal an error
          (Char
_:[Char]
plug_opt) -> [Char]
plug_opt -- ignore the ':' from break

addExternalPlugin :: String -> DynFlags -> DynFlags
addExternalPlugin :: [Char] -> DynFlags -> DynFlags
addExternalPlugin [Char]
optflag DynFlags
d = case [Char] -> Maybe ExternalPluginSpec
parseExternalPluginSpec [Char]
optflag of
  Just ExternalPluginSpec
r  -> DynFlags
d { externalPluginSpecs :: [ExternalPluginSpec]
externalPluginSpecs = ExternalPluginSpec
r forall a. a -> [a] -> [a]
: DynFlags -> [ExternalPluginSpec]
externalPluginSpecs DynFlags
d }
  Maybe ExternalPluginSpec
Nothing -> forall a. [Char] -> a
cmdLineError forall a b. (a -> b) -> a -> b
$ [Char]
"Couldn't parse external plugin specification: " forall a. [a] -> [a] -> [a]
++ [Char]
optflag

addFrontendPluginOption :: String -> DynFlags -> DynFlags
addFrontendPluginOption :: [Char] -> DynFlags -> DynFlags
addFrontendPluginOption [Char]
s DynFlags
d = DynFlags
d { frontendPluginOpts :: [[Char]]
frontendPluginOpts = [Char]
s forall a. a -> [a] -> [a]
: DynFlags -> [[Char]]
frontendPluginOpts DynFlags
d }

parseDynLibLoaderMode :: [Char] -> DynFlags -> DynFlags
parseDynLibLoaderMode [Char]
f DynFlags
d =
 case 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])
_                    -> forall a. GhcException -> a
throwGhcException ([Char] -> GhcException
CmdLineError ([Char]
"Unknown dynlib loader: " 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}

-- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
-- Config.hs should really use Option.
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, 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 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 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 forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_cxx ToolSettings
s})
addOptP :: [Char] -> DynFlags -> DynFlags
addOptP   [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
          { toolSettings_opt_P :: [[Char]]
toolSettings_opt_P   = [Char]
f 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 forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_P ToolSettings
s)
          }
          -- See Note [Repeated -optP hashing]
  where
  fingerprintStrings :: [[Char]] -> Fingerprint
fingerprintStrings [[Char]]
ss = [Fingerprint] -> Fingerprint
fingerprintFingerprints forall a b. (a -> b) -> a -> b
$ 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 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 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 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 = forall a. a -> Maybe a
Just [Char]
f }

addHaddockOpts :: [Char] -> DynFlags -> DynFlags
addHaddockOpts [Char]
f DynFlags
d = DynFlags
d { haddockOptions :: Maybe [Char]
haddockOptions = forall a. a -> Maybe a
Just [Char]
f}

addGhciScript :: [Char] -> DynFlags -> DynFlags
addGhciScript [Char]
f DynFlags
d = DynFlags
d { ghciScripts :: [[Char]]
ghciScripts = [Char]
f 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 = forall a. a -> Maybe a
Just [Char]
f}

-----------------------------------------------------------------------------
-- Setting the optimisation level

updOptLevelChanged :: Int -> DynFlags -> (DynFlags, Bool)
-- ^ Sets the 'DynFlags' to be appropriate to the optimisation level and signals if any changes took place
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 = forall a. Ord a => a -> a -> a
max Int
0 (forall a. Ord a => a -> a -> a
min Int
2 Int
n)    -- Clamp to 0 <= n <= 2
   (DynFlags
dfs1, Bool
changed1) = 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) = 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 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 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 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
-- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
updOptLevel :: Int -> DynFlags -> DynFlags
updOptLevel Int
n = forall a b. (a, b) -> a
fst forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> DynFlags -> (DynFlags, Bool)
updOptLevelChanged Int
n

{- **********************************************************************
%*                                                                      *
                DynFlags parser
%*                                                                      *
%********************************************************************* -}

-- -----------------------------------------------------------------------------
-- Parsing the dynamic flags.


-- | Parse dynamic flags from a list of command line arguments.  Returns
-- the parsed 'DynFlags', the left-over arguments, and a list of warnings.
-- Throws a 'UsageError' if errors occurred during parsing (such as unknown
-- flags or missing arguments).
parseDynamicFlagsCmdLine :: MonadIO m => DynFlags -> [Located String]
                         -> m (DynFlags, [Located String], [Warn])
                            -- ^ Updated 'DynFlags', left-over arguments, and
                            -- list of warnings.
parseDynamicFlagsCmdLine :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> [Located [Char]] -> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFlagsCmdLine = forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> Bool
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
flagsAll Bool
True


-- | Like 'parseDynamicFlagsCmdLine' but does not allow the package flags
-- (-package, -hide-package, -ignore-package, -hide-all-packages, -package-db).
-- Used to parse flags set in a modules pragma.
parseDynamicFilePragma :: MonadIO m => DynFlags -> [Located String]
                       -> m (DynFlags, [Located String], [Warn])
                          -- ^ Updated 'DynFlags', left-over arguments, and
                          -- list of warnings.
parseDynamicFilePragma :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> [Located [Char]] -> m (DynFlags, [Located [Char]], [Warn])
parseDynamicFilePragma = 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)
  deriving (forall a b. a -> CmdLineP s b -> CmdLineP s a
forall a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
forall s a b. a -> CmdLineP s b -> CmdLineP s a
forall s a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
<$ :: forall a b. a -> CmdLineP s b -> CmdLineP s a
$c<$ :: forall s a b. a -> CmdLineP s b -> CmdLineP s a
fmap :: forall a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
$cfmap :: forall s a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
Functor)

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 s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (forall (m :: * -> *). Monad m => StateT s m a
k 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 -> forall (m :: * -> *). Monad m => StateT s m b
g)
    return :: forall a. a -> CmdLineP s a
return = 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 s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
    <*> :: forall a 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

getCmdLineState :: CmdLineP s s
getCmdLineState :: forall s. CmdLineP s s
getCmdLineState = forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP 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 s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (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 = forall a. Identity a -> a
runIdentity forall a b. (a -> b) -> a -> b
$ forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT forall (m :: * -> *). Monad m => StateT s m a
k s
s0

-- | A helper to parse a set of flags from a list of command-line arguments, handling
-- response files.
processCmdLineP
    :: forall s m. MonadIO m
    => [Flag (CmdLineP s)]  -- ^ valid flags to match against
    -> s                    -- ^ current state
    -> [Located String]     -- ^ arguments to parse
    -> m (([Located String], [Err], [Warn]), s)
                            -- ^ (leftovers, errors, warnings)
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 =
    forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (forall (m :: * -> *).
Monad m =>
[Flag m]
-> [Located [Char]]
-> ([Char] -> EwM m [Located [Char]])
-> m ([Located [Char]], [Err], [Warn])
processArgs (forall a b. (a -> b) -> [a] -> [b]
map (forall (m :: * -> *) (n :: * -> *).
(forall a. m a -> n a) -> Flag m -> Flag n
hoistFlag forall a. CmdLineP s a -> StateT s m a
getCmdLineP) [Flag (CmdLineP s)]
activeFlags) [Located [Char]]
args 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) = forall (m :: * -> *). Monad m => StateT s m a
k

-- | Parses the dynamically set flags for GHC. This is the most general form of
-- the dynamic flag parser that the other methods simply wrap. It allows
-- saying which flags are valid flags and indicating if we are parsing
-- arguments from the command line or from a file pragma.
parseDynamicFlagsFull
    :: forall m. MonadIO m
    => [Flag (CmdLineP DynFlags)]    -- ^ valid flags to match against
    -> Bool                          -- ^ are the arguments from the command line?
    -> DynFlags                      -- ^ current dynamic flags
    -> [Located String]              -- ^ arguments to parse
    -> 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) <- 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

  -- See Note [Handling errors when parsing command-line flags]
  let rdr :: SDoc -> [Char]
rdr = SDocContext -> SDoc -> [Char]
renderWithContext (DynFlags -> PprStyle -> SDocContext
initSDocContext DynFlags
dflags0 PprStyle
defaultUserStyle)
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Err]
errs) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ forall a. GhcException -> IO a
throwGhcExceptionIO forall a b. (a -> b) -> a -> b
$ [([Char], [Char])] -> GhcException
errorsToGhcException forall a b. (a -> b) -> a -> b
$
    forall a b. (a -> b) -> [a] -> [b]
map ((SDoc -> [Char]
rdr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Outputable a => a -> SDoc
ppr forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall l e. GenLocated l e -> l
getLoc forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& forall l e. GenLocated l e -> e
unLoc) forall b c a. (b -> c) -> (a -> b) -> a -> c
. Err -> Located [Char]
errMsg) forall a b. (a -> b) -> a -> b
$ [Err]
errs

  -- check for disabled flags in safe haskell
  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

  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Ways -> Bool
allowed_combination Ways
theWays) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$
      forall a. GhcException -> IO a
throwGhcExceptionIO ([Char] -> GhcException
CmdLineError ([Char]
"combination not supported: " forall a. [a] -> [a] -> [a]
++
                               forall a. [a] -> [[a]] -> [a]
intercalate [Char]
"/" (forall a b. (a -> b) -> [a] -> [b]
map Way -> [Char]
wayDesc (forall a. Set a -> [a]
Set.toAscList Ways
theWays))))

  let (DynFlags
dflags3, [Located [Char]]
consistency_warnings) = DynFlags -> (DynFlags, [Located [Char]])
makeDynFlagsConsistent DynFlags
dflags2

  -- Set timer stats & heap size
  forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DynFlags -> Bool
enableTimeStats DynFlags
dflags3) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO IO ()
enableTimingStats
  case (DynFlags -> Maybe Int
ghcHeapSize DynFlags
dflags3) of
    Just Int
x -> forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (Int -> IO ()
setHeapSize Int
x)
    Maybe Int
_      -> forall (m :: * -> *) a. Monad m => a -> m a
return ()

  forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO forall a b. (a -> b) -> a -> b
$ DynFlags -> IO ()
setUnsafeGlobalDynFlags DynFlags
dflags3

  let warns' :: [Warn]
warns' = forall a b. (a -> b) -> [a] -> [b]
map (DiagnosticReason -> Located [Char] -> Warn
Warn DiagnosticReason
WarningWithoutFlag) ([Located [Char]]
consistency_warnings forall a. [a] -> [a] -> [a]
++ [Located [Char]]
sh_warns)

  forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags
dflags3, [Located [Char]]
leftover, [Warn]
warns' forall a. [a] -> [a] -> [a]
++ [Warn]
warns)

-- | Check (and potentially disable) any extensions that aren't allowed
-- in safe mode.
--
-- The bool is to indicate if we are parsing command line flags (false means
-- file pragma). This allows us to generate better warnings.
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
    -- Handle illegal flags under safe language.
    (DynFlags
dflagsUnset, [Located [Char]]
warns) = forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' 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 forall a. [a] -> [a] -> [a]
++ 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
       = [forall l e. l -> e -> GenLocated l e
L l
loc forall a b. (a -> b) -> a -> b
$ [Char]
str forall a. [a] -> [a] -> [a]
++ [Char]
" is not allowed in Safe Haskell; ignoring "
           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 and warn for when -fpackage-trust by itself with no safe
    -- haskell flag
    (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 = [forall l e. l -> e -> GenLocated l e
L (DynFlags -> SrcSpan
pkgTrustOnLoc DynFlags
dflags') forall a b. (a -> b) -> a -> b
$
                    [Char]
"-fpackage-trust ignored;" forall a. [a] -> [a] -> [a]
++
                    [Char]
" must be specified with a Safe Haskell flag"]

    -- Have we inferred Unsafe? See Note [Safe Haskell Inference] in GHC.Driver.Main
    -- Force this to avoid retaining reference to old DynFlags value
    !safeFlags :: Bool
safeFlags = forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all (\([Char]
_,DynFlags -> SrcSpan
_,DynFlags -> Bool
t,DynFlags -> DynFlags
_) -> Bool -> Bool
not forall a b. (a -> b) -> a -> b
$ DynFlags -> Bool
t DynFlags
dflags) [([Char], DynFlags -> SrcSpan, DynFlags -> Bool,
  DynFlags -> DynFlags)]
unsafeFlagsForInfer


{- **********************************************************************
%*                                                                      *
                DynFlags specifications
%*                                                                      *
%********************************************************************* -}

-- | All dynamic flags option strings without the deprecated ones.
-- These are the user facing strings for enabling and disabling options.
allNonDeprecatedFlags :: [String]
allNonDeprecatedFlags :: [[Char]]
allNonDeprecatedFlags = Bool -> [[Char]]
allFlagsDeps Bool
False

-- | All flags with possibility to filter deprecated ones
allFlagsDeps :: Bool -> [String]
allFlagsDeps :: Bool -> [[Char]]
allFlagsDeps Bool
keepDeprecated = [ Char
'-'forall a. a -> [a] -> [a]
: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

{-
 - Below we export user facing symbols for GHC dynamic flags for use with the
 - GHC API.
 -}

-- All dynamic flags present in GHC.
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsAll :: [Flag (CmdLineP DynFlags)]
flagsAll = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps

-- All dynamic flags present in GHC with deprecation information.
flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps :: [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps =  [(Deprecation, Flag (CmdLineP DynFlags))]
package_flags_deps forall a. [a] -> [a] -> [a]
++ [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps


-- All dynamic flags, minus package flags, present in GHC.
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsDynamic :: [Flag (CmdLineP DynFlags)]
flagsDynamic = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps

-- ALl package flags present in GHC.
flagsPackage :: [Flag (CmdLineP DynFlags)]
flagsPackage :: [Flag (CmdLineP DynFlags)]
flagsPackage = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
package_flags_deps

----------------Helpers to make flags and keep deprecation information----------

type FlagMaker m = String -> OptKind m -> Flag m
type DynFlagMaker = FlagMaker (CmdLineP DynFlags)
data Deprecation = NotDeprecated | Deprecated deriving (Deprecation -> Deprecation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Deprecation -> Deprecation -> Bool
$c/= :: Deprecation -> Deprecation -> Bool
== :: Deprecation -> Deprecation -> Bool
$c== :: Deprecation -> Deprecation -> Bool
Eq, Eq 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
min :: Deprecation -> Deprecation -> Deprecation
$cmin :: Deprecation -> Deprecation -> Deprecation
max :: Deprecation -> Deprecation -> Deprecation
$cmax :: Deprecation -> Deprecation -> Deprecation
>= :: Deprecation -> Deprecation -> Bool
$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
compare :: Deprecation -> Deprecation -> Ordering
$ccompare :: Deprecation -> Deprecation -> Ordering
Ord)

-- Make a non-deprecated flag
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 a deprecated flag
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 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 = forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ DynP ()
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (HasArg [Char] -> DynP ()
f) [Char]
message = forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (SepArg [Char] -> DynP ()
f) [Char]
message = forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (Prefix [Char] -> DynP ()
f) [Char]
message = forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (OptPrefix [Char] -> DynP ()
f) [Char]
message =
                                  forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
OptPrefix forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (OptIntSuffix Maybe Int -> DynP ()
f) [Char]
message =
                               forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix forall a b. (a -> b) -> a -> b
$ \Maybe Int
oi -> Maybe Int -> DynP ()
f Maybe Int
oi forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (IntSuffix Int -> DynP ()
f) [Char]
message =
                                  forall (m :: * -> *). (Int -> EwM m ()) -> OptKind m
IntSuffix forall a b. (a -> b) -> a -> b
$ \Int
i -> Int -> DynP ()
f Int
i forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (WordSuffix Word -> DynP ()
f) [Char]
message =
                                  forall (m :: * -> *). (Word -> EwM m ()) -> OptKind m
WordSuffix forall a b. (a -> b) -> a -> b
$ \Word
i -> Word -> DynP ()
f Word
i forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (FloatSuffix Float -> DynP ()
f) [Char]
message =
                                forall (m :: * -> *). (Float -> EwM m ()) -> OptKind m
FloatSuffix forall a b. (a -> b) -> a -> b
$ \Float
fl -> Float -> DynP ()
f Float
fl forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (PassFlag [Char] -> DynP ()
f) [Char]
message =
                                   forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
PassFlag forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message
add_dep_message (AnySuffix [Char] -> DynP ()
f) [Char]
message =
                                  forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
AnySuffix forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
message

----------------------- The main flags themselves ------------------------------
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
dynamic_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps = [
    DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"n" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *) a. Monad m => a -> m a
return ())
        [Char]
"The -n flag is deprecated and no longer has any effect"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"cpp"      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Extension -> DynP ()
setExtensionFlag Extension
LangExt.Cpp))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"F"        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Pp))
  , (Deprecation
Deprecated, forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"#include"
      (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
_s ->
         forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate ([Char]
"-#include and INCLUDE pragmas are " forall a. [a] -> [a] -> [a]
++
                    [Char]
"deprecated: They no longer have any effect"))))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"v"        (forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix Maybe Int -> DynP ()
setVerbosity)

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"j"     (forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix
        (\Maybe Int
n -> case Maybe Int
n of
                 Just Int
n
                     | Int
n forall a. Ord a => a -> a -> Bool
> Int
0     -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { parMakeCount :: Maybe Int
parMakeCount = forall a. a -> Maybe a
Just Int
n })
                     | Bool
otherwise -> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addErr [Char]
"Syntax: -j[n] where n > 0"
                 Maybe Int
Nothing -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { parMakeCount :: Maybe Int
parMakeCount = forall a. Maybe a
Nothing })))
                 -- When the number of parallel builds
                 -- is omitted, it is the same
                 -- as specifying that the number of
                 -- parallel builds is equal to the
                 -- result of getNumProcessors
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"instantiated-with"   (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg [Char] -> DynFlags -> DynFlags
setUnitInstantiations)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"this-component-id"   (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg [Char] -> DynFlags -> DynFlags
setUnitInstanceOf)

    -- RTS options -------------------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"H"           (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
s -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d ->
          DynFlags
d { ghcHeapSize :: Maybe Int
ghcHeapSize = forall a. a -> Maybe a
Just forall a b. (a -> b) -> a -> b
$ forall a b. (Integral a, Num b) => a -> b
fromIntegral ([Char] -> Integer
decodeSize [Char]
s)})))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Rghc-timing" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d ->
                                               DynFlags
d { enableTimeStats :: Bool
enableTimeStats = Bool
True })))

    ------- ways ---------------------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"prof"           (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWayDynP Way
WayProf))
  , (Deprecation
Deprecated, forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag     [Char]
"eventlog"
     forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> do
         forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
"the eventlog is now enabled in all runtime system ways"
         forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
d)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"debug"          (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWayDynP Way
WayDebug))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"threaded"       (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWayDynP Way
WayThreaded))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Way -> DynP ()
addWayDynP Way
WayDebug))

    -- -ticky enables ticky-ticky code generation, and also implies -debug which
    -- is required to get the RTS ticky support.

        ----- Linker --------------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"static"         (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeWayDyn)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynamic"        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWayDynP Way
WayDyn))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rdynamic" forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg forall a b. (a -> b) -> a -> b
$
#if defined(linux_HOST_OS)
                              [Char] -> DynFlags -> DynFlags
addOptl [Char]
"-rdynamic"
#elif defined(mingw32_HOST_OS)
                              addOptl "-Wl,--export-all-symbols"
#else
    -- ignored for compat w/ gcc:
                              id
#endif
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"relative-dynlib-paths"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_RelativeDynlibPaths))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"copy-libs-when-linking"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SingleLibFolder))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"pie"            (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PICExecutable))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-pie"         (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_PICExecutable))

        ------- Specific phases  --------------------------------------------
    -- need to appear before -pgmL to be parsed as LLVM flags.
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlo"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_lo :: ([Char], [Option])
toolSettings_pgm_lo  = ([Char]
f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlc"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_lc :: ([Char], [Option])
toolSettings_pgm_lc  = ([Char]
f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlm"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_lm :: Maybe ([Char], [Option])
toolSettings_pgm_lm  =
          if forall (t :: * -> *) a. Foldable t => t a -> Bool
null [Char]
f then forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just ([Char]
f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmi"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_i :: [Char]
toolSettings_pgm_i   =  [Char]
f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmL"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_L :: [Char]
toolSettings_pgm_L   = [Char]
f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmP"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setPgmP)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmF"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_F :: [Char]
toolSettings_pgm_F   = [Char]
f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmc"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_c :: [Char]
toolSettings_pgm_c   = [Char]
f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmcxx"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_cxx :: [Char]
toolSettings_pgm_cxx = [Char]
f }
  , (Deprecation
Deprecated, forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag  [Char]
"pgmc-supports-no-pie"
      forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM  forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> do
        forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ [Char]
"use -pgml-supports-no-pie instead"
        forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_ccSupportsNoPie :: Bool
toolSettings_ccSupportsNoPie = Bool
True }) DynFlags
d)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgms"
      (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
_ -> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addWarn [Char]
"Object splitting was removed in GHC 8.8"))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgma"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_a :: ([Char], [Option])
toolSettings_pgm_a   = ([Char]
f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgml"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
         { toolSettings_pgm_l :: ([Char], [Option])
toolSettings_pgm_l   = ([Char]
f,[])
         , -- Don't pass -no-pie with custom -pgml (see #15319). Note
           -- that this could break when -no-pie is actually needed.
           -- But the CC_SUPPORTS_NO_PIE check only happens at
           -- buildtime, and -pgml is a runtime option. A better
           -- solution would be running this check for each custom
           -- -pgml.
           toolSettings_ccSupportsNoPie :: Bool
toolSettings_ccSupportsNoPie = Bool
False
         }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgml-supports-no-pie"
      forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg forall a b. (a -> b) -> a -> b
$ (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_ccSupportsNoPie :: Bool
toolSettings_ccSupportsNoPie = Bool
True }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmdll"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_dll :: ([Char], [Option])
toolSettings_pgm_dll = ([Char]
f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmwindres"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_windres :: [Char]
toolSettings_pgm_windres = [Char]
f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmar"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_ar :: [Char]
toolSettings_pgm_ar = [Char]
f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmotool"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_otool :: [Char]
toolSettings_pgm_otool = [Char]
f}
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgminstall_name_tool"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_install_name_tool :: [Char]
toolSettings_pgm_install_name_tool = [Char]
f}
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmranlib"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_ranlib :: [Char]
toolSettings_pgm_ranlib = [Char]
f }


    -- need to appear before -optl/-opta to be parsed as LLVM flags.
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlm"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_lm :: [[Char]]
toolSettings_opt_lm  = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_lm ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlo"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_lo :: [[Char]]
toolSettings_opt_lo  = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_lo ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlc"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_lc :: [[Char]]
toolSettings_opt_lc  = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_lc ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"opti"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_i :: [[Char]]
toolSettings_opt_i   = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_i ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optL"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_L :: [[Char]]
toolSettings_opt_L   = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_L ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optP"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addOptP)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optF"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_F :: [[Char]]
toolSettings_opt_F   = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_F ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optc"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addOptc)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optcxx"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addOptcxx)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"opta"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_a :: [[Char]]
toolSettings_opt_a   = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_a ToolSettings
s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optl"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addOptl)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optwindres"
      forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg forall a b. (a -> b) -> a -> b
$ \[Char]
f ->
        (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_windres :: [[Char]]
toolSettings_opt_windres = [Char]
f forall a. a -> [a] -> [a]
: ToolSettings -> [[Char]]
toolSettings_opt_windres ToolSettings
s }

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"split-objs"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addWarn [Char]
"ignoring -split-objs")

    -- N.B. We may someday deprecate this in favor of -fsplit-sections,
    -- which has the benefit of also having a negating -fno-split-sections.
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"split-sections"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SplitSections)

        -------- ghc -M -----------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dep-suffix"              (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addDepSuffix)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dep-makefile"            (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setDepMakefile)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"include-cpp-deps"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (Bool -> DynFlags -> DynFlags
setDepIncludeCppDeps Bool
True))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"include-pkg-deps"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (Bool -> DynFlags -> DynFlags
setDepIncludePkgDeps Bool
True))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"exclude-module"          (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addDepExcludeMod)

        -------- Linking ----------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-link"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
NoLink }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"shared"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
LinkDynLib }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"staticlib"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' GeneralFlag
Opt_LinkRts (DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
LinkStaticLib })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"-merge-objs"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
LinkMergedObj }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynload"            (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
parseDynLibLoaderMode)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dylib-install-name" (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setDylibInstallName)

        ------- Libraries ---------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"L"   (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix [Char] -> DynP ()
addLibraryPath)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"l"   (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Option -> DynFlags -> DynFlags
addLdInputs forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Option
Option forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"-l" forall a. [a] -> [a] -> [a]
++)))

        ------- Frameworks --------------------------------------------------
        -- -framework-path should really be -F ...
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"framework-path" (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
addFrameworkPath)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"framework"      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addCmdlineFramework)

        ------- Output Redirection ------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"odir"              (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setObjectDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"o"                 (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (Maybe [Char] -> DynFlags -> DynFlags
setOutputFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dyno"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (Maybe [Char] -> DynFlags -> DynFlags
setDynOutputFile forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ohi"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Maybe [Char] -> DynFlags -> DynFlags
setOutputHi forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynohi"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Maybe [Char] -> DynFlags -> DynFlags
setDynOutputHi forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"osuf"              (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setObjectSuf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynosuf"           (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setDynObjectSuf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hcsuf"             (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setHcSuf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hisuf"             (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setHiSuf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hiesuf"            (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setHieSuf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynhisuf"          (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setDynHiSuf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hidir"             (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setHiDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hiedir"            (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setHieDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"tmpdir"            (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setTmpDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"stubdir"           (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setStubDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dumpdir"           (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setDumpDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"outputdir"         (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setOutputDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-file-prefix"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Maybe [Char] -> DynFlags -> DynFlags
setDumpPrefixForce forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. a -> Maybe a
Just forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b c. (a -> b -> c) -> b -> a -> c
flip forall a. [a] -> [a] -> [a]
(++) [Char]
"."))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynamic-too"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_BuildDynamicToo))

        ------- Keeping temporary files -------------------------------------
     -- These can be singular (think ghc -c) or plural (think ghc --make)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hc-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHcFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hc-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHcFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hscpp-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHscppFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hscpp-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHscppFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-s-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepSFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-s-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepSFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-llvm-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ Backend -> DynP ()
setObjBackend Backend
llvmBackend forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepLlvmFiles)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-llvm-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ Backend -> DynP ()
setObjBackend Backend
llvmBackend forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepLlvmFiles)
     -- This only makes sense as plural
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-tmp-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepTmpFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hi-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-hi-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hi-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-hi-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepHiFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-o-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepOFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-o-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepOFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-o-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepOFiles))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-o-files"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_KeepOFiles))

        ------- Miscellaneous ----------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-auto-link-packages"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_AutoLinkPackages))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-hs-main"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_NoHsMain))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-state-hack"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_G_NoStateHack))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-opt-coercion"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_G_NoOptCoercion))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"with-rtsopts"
        (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
setRtsOpts)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsAll))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=all"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsAll))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=some"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsSafeOnly))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=none"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsNone))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=ignore"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsIgnore))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=ignoreAll"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsIgnoreAll))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-rtsopts"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsNone))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-rtsopts-suggestions"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d {rtsOptsSuggestions :: Bool
rtsOptsSuggestions = Bool
False}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dhex-word-literals"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_HexWordLiterals))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ghcversion-file"      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addGhcVersionFile)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"main-is"              (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg [Char] -> DynP ()
setMainIs)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"haddock"              (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Haddock))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-haddock"           (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_Haddock))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"haddock-opts"         (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addHaddockOpts)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hpcdir"               (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg [Char] -> DynP ()
setOptHpcDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhciFlag [Char]
"ghci-script"         (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addGhciScript)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhciFlag [Char]
"interactive-print"   (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setInteractivePrint)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-allocd"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky_Allocd))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-LNE"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky_LNE))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-ap-thunk"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky_AP))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-dyn-thunk"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky_Dyn_Thunk))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-tag-checks"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky_Tag))
        ------- recompilation checker --------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"recomp"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_ForceRecomp)
             [Char]
"Use -fno-force-recomp instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-recomp"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_ForceRecomp) [Char]
"Use -fforce-recomp instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-errors"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxErrors :: Maybe Int
maxErrors = forall a. a -> Maybe a
Just (forall a. Ord a => a -> a -> a
max Int
1 Int
n) }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-max-errors"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { maxErrors :: Maybe Int
maxErrors = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"freverse-errors"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d {reverseErrors :: Bool
reverseErrors = Bool
True} ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-reverse-errors"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d {reverseErrors :: Bool
reverseErrors = Bool
False} ))

        ------ HsCpp opts ---------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"D"              (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
AnySuffix ((DynFlags -> DynFlags) -> DynP ()
upd forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
addOptP))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"U"              (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
AnySuffix ((DynFlags -> DynFlags) -> DynP ()
upd forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
addOptP))

        ------- Include/Import Paths ----------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"I"              (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix    [Char] -> DynP ()
addIncludePath)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"i"              (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
OptPrefix [Char] -> DynP ()
addImportPath)

        ------ Output style options -----------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"dppr-user-length" ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d ->
                                                       DynFlags
d { pprUserLength :: Int
pprUserLength = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"dppr-cols"        ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d ->
                                                             DynFlags
d { pprCols :: Int
pprCols = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdiagnostics-color=auto"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useColor :: OverridingBool
useColor = OverridingBool
Auto })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdiagnostics-color=always"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useColor :: OverridingBool
useColor = OverridingBool
Always })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdiagnostics-color=never"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useColor :: OverridingBool
useColor = OverridingBool
Never })))

  -- Suppress all that is suppressible in core dumps.
  -- Except for uniques, as some simplifier phases introduce new variables that
  -- have otherwise identical names.
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dsuppress-all"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ do GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressCoercions
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressCoercionTypes
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressVarKinds
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressModulePrefixes
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressTypeApplications
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressIdInfo
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressTicks
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressStgExts
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressStgReps
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressTypeSignatures
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressCoreSizes
                  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SuppressTimestamps)

        ------ Debugging ----------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dstg-stats"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_StgStats))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-from-stg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_from_stg)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-raw"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_raw)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-verbose"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_verbose)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-verbose-by-proc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_verbose_by_proc)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-cfg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_cfg)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-cbe"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_cbe)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-switch"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_switch)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-proc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_proc)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-sp"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_sp)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-sink"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_sink)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-caf"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_caf)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-procmap"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_procmap)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-split"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_split)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-info"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_info)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-cps"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_cps)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-opt"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_opt_cmm)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cmm-thread-sanitizer"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cmm_thread_sanitizer)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cfg-weights"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cfg_weights)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-core-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_core_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-js"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_js)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm-native"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_native)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm-liveness"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_liveness)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm-regalloc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_regalloc)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm-conflicts"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_conflicts)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm-regalloc-stages"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_regalloc_stages)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-asm-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_asm_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-llvm"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_llvm)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-c-backend"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_c_backend)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-deriv"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_deriv)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-ds"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ds)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-ds-preopt"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ds_preopt)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-foreign"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_foreign)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-inlinings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_inlinings)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-verbose-inlinings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_verbose_inlinings)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rule-firings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rule_firings)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rule-rewrites"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rule_rewrites)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-simpl-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl_trace)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-occur-anal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_occur_anal)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-parsed"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_parsed)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-parsed-ast"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_parsed_ast)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dkeep-comments"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepRawTokenStream))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rn"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rn-ast"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn_ast)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-simpl"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-simpl-iterations"
      (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl_iterations)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-spec"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_spec)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-prep"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_prep)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-late-cc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_late_cc)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stg-from-core"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_from_core)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stg-unarised"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_unarised)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stg-final"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_final)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stg-cg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_cg)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_from_core)
        [Char]
"Use `-ddump-stg-from-core` or `-ddump-stg-final` instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stg-tags"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_tags)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-call-arity"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_call_arity)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-exitify"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_exitify)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stranal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stranal)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-str-signatures"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_str_signatures)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cpranal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cpranal)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cpr-signatures"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cpr_signatures)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-tc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_tc)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-tc-ast"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_tc_ast)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-hie"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_hie)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-types"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_types)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rules"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rules)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cse"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cse)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-worker-wrapper"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_worker_wrapper)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rn-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn_trace)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-if-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_if_trace)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-cs-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_cs_trace)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-tc-trace"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (do DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_tc_trace
                   DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_cs_trace))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-ec-trace"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ec_trace)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-splices"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_splices)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dth-dec-file"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_th_dec_file)

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rn-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rn_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-opt-cmm" --old alias for cmm-opt
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_opt_cmm)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-simpl-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_simpl_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-bcos"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_BCOs)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dsource-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_source_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dverbose-core2core"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ Maybe Int -> DynP ()
setVerbosity (forall a. a -> Maybe a
Just Int
2) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_verbose_core2core)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dverbose-stg2stg"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_verbose_stg2stg)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-hi"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_hi)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-minimal-imports"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_D_dump_minimal_imports))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-hpc"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ticked) -- back compat
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-ticked"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_ticked)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-mod-cycles"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_mod_cycles)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-mod-map"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_mod_map)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-timings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_timings)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-view-pattern-commoning"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_view_pattern_commoning)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-to-file"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DumpToFile))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-hi-diffs"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_hi_diffs)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-rtti"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_rtti)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dlint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
enableDLint)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dcore-lint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoCoreLinting))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dlinear-core-lint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoLinearCoreLinting))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dstg-lint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoStgLinting))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dcmm-lint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoCmmLinting))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dasm-lint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoAsmLinting))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dannot-lint"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoAnnotationLinting))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dtag-inference-checks"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DoTagInferenceChecks))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dshow-passes"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg forall a b. (a -> b) -> a -> b
$ DynP ()
forceRecompile forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Maybe Int -> DynP ()
setVerbosity forall a b. (a -> b) -> a -> b
$ forall a. a -> Maybe a
Just Int
2))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dfaststring-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_faststring_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dno-llvm-mangler"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_NoLlvmMangler)) -- hidden flag
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dno-typeable-binds"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_NoTypeableBinds))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-debug"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_debug)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-json"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_json )
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dppr-debug"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_ppr_debug)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddebug-output"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> DumpFlag -> DynFlags
dopt_unset DumpFlag
Opt_D_no_debug_output))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dno-debug-output"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_no_debug_output)

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-faststrings"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_faststrings)

        ------ Machine dependent (-m<blah>) stuff ---------------------------

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion :: Maybe SseVersion
sseVersion = forall a. a -> Maybe a
Just SseVersion
SSE1 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse2"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion :: Maybe SseVersion
sseVersion = forall a. a -> Maybe a
Just SseVersion
SSE2 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse3"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion :: Maybe SseVersion
sseVersion = forall a. a -> Maybe a
Just SseVersion
SSE3 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse4"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion :: Maybe SseVersion
sseVersion = forall a. a -> Maybe a
Just SseVersion
SSE4 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse4.2"      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                 DynFlags
d { sseVersion :: Maybe SseVersion
sseVersion = forall a. a -> Maybe a
Just SseVersion
SSE42 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mbmi"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                 DynFlags
d { bmiVersion :: Maybe BmiVersion
bmiVersion = forall a. a -> Maybe a
Just BmiVersion
BMI1 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mbmi2"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                 DynFlags
d { bmiVersion :: Maybe BmiVersion
bmiVersion = forall a. a -> Maybe a
Just BmiVersion
BMI2 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { avx :: Bool
avx = Bool
True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx2"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { avx2 :: Bool
avx2 = Bool
True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512cd"    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                         DynFlags
d { avx512cd :: Bool
avx512cd = Bool
True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512er"    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                         DynFlags
d { avx512er :: Bool
avx512er = Bool
True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512f"     ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { avx512f :: Bool
avx512f = Bool
True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512pf"    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                         DynFlags
d { avx512pf :: Bool
avx512pf = Bool
True }))

     ------ Warning opts -------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"W"       (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
minusWOpts))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Werror"
               (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (do { GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_WarnIsError
                          ; forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setFatalWarningFlag [WarningFlag]
minusWeverythingOpts   }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wwarn"
               (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (do { GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_WarnIsError
                          ; forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetFatalWarningFlag [WarningFlag]
minusWeverythingOpts }))
                          -- Opt_WarnIsError is still needed to pass -Werror
                          -- to CPP; see runCpp in SysTools
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wnot"    (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d ->
                                              DynFlags
d {warningFlags :: EnumSet WarningFlag
warningFlags = forall a. EnumSet a
EnumSet.empty})))
                                             [Char]
"Use -w or -Wno-everything instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"w"       (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d ->
                                              DynFlags
d {warningFlags :: EnumSet WarningFlag
warningFlags = forall a. EnumSet a
EnumSet.empty})))

     -- New-style uniform warning sets
     --
     -- Note that -Weverything > -Wall > -Wextra > -Wdefault > -Wno-everything
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Weverything"    (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                           WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
minusWeverythingOpts))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-everything"
                           (forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d {warningFlags :: EnumSet WarningFlag
warningFlags = forall a. EnumSet a
EnumSet.empty})))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wall"           (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                                  WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
minusWallOpts))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-all"        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                                WarningFlag -> DynP ()
unSetWarningFlag [WarningFlag]
minusWallOpts))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wextra"         (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                                     WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
minusWOpts))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-extra"      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                                   WarningFlag -> DynP ()
unSetWarningFlag [WarningFlag]
minusWOpts))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wdefault"       (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                               WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
standardWarnings))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-default"    (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                             WarningFlag -> DynP ()
unSetWarningFlag [WarningFlag]
standardWarnings))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wcompat"        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                               WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
minusWcompatOpts))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-compat"     (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_
                                             WarningFlag -> DynP ()
unSetWarningFlag [WarningFlag]
minusWcompatOpts))

        ------ Plugin flags ------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fplugin-opt" (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addPluginModuleNameOption)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fplugin-trustworthy"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PluginTrustworthy))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fplugin"     (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addPluginModuleName)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fclear-plugins" ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg DynFlags -> DynFlags
clearPluginModuleNames)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ffrontend-opt" (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addFrontendPluginOption)

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fplugin-library" (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addExternalPlugin)

        ------ Optimisation flags ------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"Onot"   ((DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM forall a b. (a -> b) -> a -> b
$ Int -> DynFlags -> DynP DynFlags
setOptLevel Int
0 )
                                                            [Char]
"Use -O0 instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"O"      ((Maybe Int -> DynFlags -> DynP DynFlags)
-> OptKind (CmdLineP DynFlags)
optIntSuffixM (\Maybe Int
mb_n ->
                                                Int -> DynFlags -> DynP DynFlags
setOptLevel (Maybe Int
mb_n forall a. Maybe a -> a -> a
`orElse` Int
1)))
                -- If the number is missing, use 1

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fbinary-blob-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { binBlobThreshold :: Maybe Word
binBlobThreshold = case forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
n of
                                                    Word
0 -> forall a. Maybe a
Nothing
                                                    Word
x -> forall a. a -> Maybe a
Just Word
x}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-relevant-binds"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxRelevantBinds :: Maybe Int
maxRelevantBinds = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-max-relevant-binds"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { maxRelevantBinds :: Maybe Int
maxRelevantBinds = forall a. Maybe a
Nothing }))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-valid-hole-fits"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxValidHoleFits :: Maybe Int
maxValidHoleFits = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-max-valid-hole-fits"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { maxValidHoleFits :: Maybe Int
maxValidHoleFits = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-refinement-hole-fits"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxRefHoleFits :: Maybe Int
maxRefHoleFits = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-max-refinement-hole-fits"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { maxRefHoleFits :: Maybe Int
maxRefHoleFits = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"frefinement-level-hole-fits"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { refLevelHoleFits :: Maybe Int
refLevelHoleFits = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-refinement-level-hole-fits"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { refLevelHoleFits :: Maybe Int
refLevelHoleFits = forall a. Maybe a
Nothing }))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fllvm-pass-vectors-in-regs"
            ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg forall a. a -> a
id)
            [Char]
"vectors registers are now passed in registers by default."
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-uncovered-patterns"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxUncoveredPatterns :: Int
maxUncoveredPatterns = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-pmcheck-models"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxPmCheckModels :: Int
maxPmCheckModels = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fsimplifier-phases"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { simplPhases :: Int
simplPhases = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-simplifier-iterations"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxSimplIterations :: Int
maxSimplIterations = Int
n }))
  , (Deprecation
Deprecated, forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-pmcheck-iterations"
      ((Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM (\Int
_ DynFlags
d ->
       do { forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ [Char]
"use -fmax-pmcheck-models instead"
          ; forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
d })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fsimpl-tick-factor"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { simplTickFactor :: Int
simplTickFactor = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdmd-unbox-width"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { dmdUnboxWidth :: Int
dmdUnboxWidth = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fspec-constr-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { specConstrThreshold :: Maybe Int
specConstrThreshold = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-spec-constr-threshold"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { specConstrThreshold :: Maybe Int
specConstrThreshold = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fspec-constr-count"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { specConstrCount :: Maybe Int
specConstrCount = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-spec-constr-count"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { specConstrCount :: Maybe Int
specConstrCount = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fspec-constr-recursive"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { specConstrRecursive :: Int
specConstrRecursive = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fliberate-case-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { liberateCaseThreshold :: Maybe Int
liberateCaseThreshold = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-liberate-case-threshold"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liberateCaseThreshold :: Maybe Int
liberateCaseThreshold = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"drule-check"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (\[Char]
s DynFlags
d -> DynFlags
d { ruleCheck :: Maybe [Char]
ruleCheck = forall a. a -> Maybe a
Just [Char]
s }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"dinline-check"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (\[Char]
s DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Maybe [Char] -> UnfoldingOpts -> UnfoldingOpts
updateReportPrefix (forall a. a -> Maybe a
Just [Char]
s) (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"freduction-depth"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { reductionDepth :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fconstraint-solver-iterations"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { solverIterations :: IntWithInf
solverIterations = Int -> IntWithInf
treatZeroAsInf Int
n }))
  , (Deprecation
Deprecated, forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fcontext-stack"
      ((Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM (\Int
n DynFlags
d ->
       do { forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ [Char]
"use -freduction-depth=" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
n forall a. [a] -> [a] -> [a]
++ [Char]
" instead"
          ; forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ DynFlags
d { reductionDepth :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
n } })))
  , (Deprecation
Deprecated, forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"ftype-function-depth"
      ((Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM (\Int
n DynFlags
d ->
       do { forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ [Char]
"use -freduction-depth=" forall a. [a] -> [a] -> [a]
++ forall a. Show a => a -> [Char]
show Int
n forall a. [a] -> [a] -> [a]
++ [Char]
" instead"
          ; forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ DynFlags
d { reductionDepth :: IntWithInf
reductionDepth = Int -> IntWithInf
treatZeroAsInf Int
n } })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fstrictness-before"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { strictnessBefore :: [Int]
strictnessBefore = Int
n forall a. a -> [a] -> [a]
: DynFlags -> [Int]
strictnessBefore DynFlags
d }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"ffloat-lam-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { floatLamArgs :: Maybe Int
floatLamArgs = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"ffloat-all-lams"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { floatLamArgs :: Maybe Int
floatLamArgs = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fstg-lift-lams-rec-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fstg-lift-lams-rec-args-any"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsRecArgs :: Maybe Int
liftLamsRecArgs = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fstg-lift-lams-non-rec-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { liftLamsNonRecArgs :: Maybe Int
liftLamsNonRecArgs = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fstg-lift-lams-non-rec-args-any"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsNonRecArgs :: Maybe Int
liftLamsNonRecArgs = forall a. Maybe a
Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fstg-lift-lams-known"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsKnown :: Bool
liftLamsKnown = Bool
True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-stg-lift-lams-known"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { liftLamsKnown :: Bool
liftLamsKnown = Bool
False }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fproc-alignment"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { cmmProcAlignment :: Maybe Int
cmmProcAlignment = forall a. a -> Maybe a
Just Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fblock-layout-weights"
        (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
s ->
            (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { cfgWeights :: Weights
cfgWeights =
                [Char] -> Weights -> Weights
parseWeights [Char]
s (DynFlags -> Weights
cfgWeights DynFlags
d)})))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fhistory-size"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { historySize :: Int
historySize = Int
n }))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-creation-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Int -> UnfoldingOpts -> UnfoldingOpts
updateCreationThreshold Int
n (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-use-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Int -> UnfoldingOpts -> UnfoldingOpts
updateUseThreshold Int
n (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-fun-discount"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Int -> UnfoldingOpts -> UnfoldingOpts
updateFunAppDiscount Int
n (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-dict-discount"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Int -> UnfoldingOpts -> UnfoldingOpts
updateDictDiscount Int
n (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-case-threshold"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Int -> UnfoldingOpts -> UnfoldingOpts
updateCaseThreshold Int
n (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-case-scaling"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix   (\Int
n DynFlags
d -> DynFlags
d { unfoldingOpts :: UnfoldingOpts
unfoldingOpts = Int -> UnfoldingOpts -> UnfoldingOpts
updateCaseScaling Int
n (DynFlags -> UnfoldingOpts
unfoldingOpts DynFlags
d)}))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"funfolding-keeness-factor"
      ((Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
floatSuffix (\Float
_ DynFlags
d -> DynFlags
d))
      [Char]
"-funfolding-keeness-factor is no longer respected as of GHC 9.0"

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fmax-worker-args"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d {maxWorkerArgs :: Int
maxWorkerArgs = Int
n}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhciFlag [Char]
"fghci-hist-size"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d {ghciHistSize :: Int
ghciHistSize = Int
n}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fmax-inline-alloc-size"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxInlineAllocSize :: Int
maxInlineAllocSize = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fmax-inline-memcpy-insns"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxInlineMemcpyInsns :: Int
maxInlineMemcpyInsns = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fmax-inline-memset-insns"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { maxInlineMemsetInsns :: Int
maxInlineMemsetInsns = Int
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dinitial-unique"
      ((Word -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
wordSuffix (\Word
n DynFlags
d -> DynFlags
d { initialUnique :: Word
initialUnique = Word
n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dunique-increment"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { uniqueIncrement :: Int
uniqueIncrement = Int
n }))

        ------ Profiling ----------------------------------------------------

        -- OLD profiling flags
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"auto-all"
                    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
ProfAutoAll } ))
                    [Char]
"Use -fprof-auto instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-auto-all"
                    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
NoProfAuto } ))
                    [Char]
"Use -fno-prof-auto instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"auto"
                    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
ProfAutoExports } ))
                    [Char]
"Use -fprof-auto-exported instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-auto"
            ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
NoProfAuto } ))
                    [Char]
"Use -fno-prof-auto instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"caf-all"
            (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_AutoSccsOnIndividualCafs))
                    [Char]
"Use -fprof-cafs instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-caf-all"
            (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_AutoSccsOnIndividualCafs))
                    [Char]
"Use -fno-prof-cafs instead"

        -- NEW profiling flags
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fprof-auto"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
ProfAutoAll } ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fprof-auto-top"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
ProfAutoTop } ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fprof-auto-exported"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
ProfAutoExports } ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fprof-auto-calls"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
ProfAutoCalls } ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-prof-auto"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { profAuto :: ProfAuto
profAuto = ProfAuto
NoProfAuto } ))

        -- Caller-CC
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fprof-callers"
         (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
setCallerCcFilters)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fdistinct-constructor-tables"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DistinctConstructorTables))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"finfo-table-map"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_InfoTableMap))
        ------ Compiler flags -----------------------------------------------

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fasm"             (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Backend -> DynP ()
setObjBackend Backend
ncgBackend))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fvia-c"           (forall (m :: * -> *). EwM m () -> OptKind m
NoArg
         (forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ [Char]
"The -fvia-c flag does nothing; " forall a. [a] -> [a] -> [a]
++
                      [Char]
"it will be removed in a future GHC release"))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fvia-C"           (forall (m :: * -> *). EwM m () -> OptKind m
NoArg
         (forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ [Char]
"The -fvia-C flag does nothing; " forall a. [a] -> [a] -> [a]
++
                      [Char]
"it will be removed in a future GHC release"))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fllvm"            (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Backend -> DynP ()
setObjBackend Backend
llvmBackend))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-code"         (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (((DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
d ->
                  DynFlags
d { ghcLink :: GhcLink
ghcLink=GhcLink
NoLink }) forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Backend -> DynP ()
setBackend Backend
noBackend))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fbyte-code"
      ((DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM forall a b. (a -> b) -> a -> b
$ \DynFlags
dflags -> do
        Backend -> DynP ()
setBackend Backend
interpreterBackend
        forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> GeneralFlag -> DynFlags
gopt_unset GeneralFlag
Opt_ByteCodeAndObjectCode (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dflags GeneralFlag
Opt_ByteCode))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fobject-code"     forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM forall a b. (a -> b) -> a -> b
$ \DynFlags
dflags -> do
      Backend -> DynP ()
setBackend forall a b. (a -> b) -> a -> b
$ Platform -> Backend
platformDefaultBackend (DynFlags -> Platform
targetPlatform DynFlags
dflags)
      DynFlags
dflags' <- forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM forall s. CmdLineP s s
getCmdLineState
      forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a b. (a -> b) -> a -> b
$ DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags' GeneralFlag
Opt_ByteCodeAndObjectCode

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fglasgow-exts"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
enableGlasgowExts) [Char]
"Use individual extensions instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-glasgow-exts"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
disableGlasgowExts) [Char]
"Use individual extensions instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wunused-binds" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
enableUnusedBinds)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-unused-binds" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
disableUnusedBinds)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defHiddenFlag [Char]
"fwarn-unused-binds" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
enableUnusedBinds)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defHiddenFlag [Char]
"fno-warn-unused-binds" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg
                                                            DynP ()
disableUnusedBinds)

        ------ Safe Haskell flags -------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fpackage-trust"   (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
setPackageTrust)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-safe-infer"   ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                    DynFlags
d { safeInfer :: Bool
safeInfer = Bool
False }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-safe-haskell" (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (SafeHaskellMode -> DynP ()
setSafeHaskell SafeHaskellMode
Sf_Ignore))

        ------ position independent flags  ----------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fPIC"          (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PIC))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-PIC"       (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_PIC))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fPIE"          (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PIE))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-PIE"       (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_PIE))

         ------ Debugging flags ----------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"g"             (forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix Maybe Int -> DynP ()
setDebugLevel)
 ]
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
""          GeneralFlag -> DynP ()
setGeneralFlag    ) [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"no-"       GeneralFlag -> DynP ()
unSetGeneralFlag  ) [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"d"         GeneralFlag -> DynP ()
setGeneralFlag    ) [(Deprecation, FlagSpec GeneralFlag)]
dFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"dno-"      GeneralFlag -> DynP ()
unSetGeneralFlag  ) [(Deprecation, FlagSpec GeneralFlag)]
dFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"f"         GeneralFlag -> DynP ()
setGeneralFlag    ) [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"fno-"      GeneralFlag -> DynP ()
unSetGeneralFlag  ) [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"W"         WarningFlag -> DynP ()
setWarningFlag    ) [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"Wno-"      WarningFlag -> DynP ()
unSetWarningFlag  ) [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"Werror="   WarningFlag -> DynP ()
setWErrorFlag )     [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"Wwarn="     WarningFlag -> DynP ()
unSetFatalWarningFlag )
                                                        [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"Wno-error=" WarningFlag -> DynP ()
unSetFatalWarningFlag )
                                                        [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"fwarn-"    WarningFlag -> DynP ()
setWarningFlag   forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag)
    [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"fno-warn-" WarningFlag -> DynP ()
unSetWarningFlag forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag)
    [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 forall a. [a] -> [a] -> [a]
++ [ (Deprecation
NotDeprecated, [Char] -> Flag (CmdLineP DynFlags)
unrecognisedWarning [Char]
"W"),
      (Deprecation
Deprecated,    [Char] -> Flag (CmdLineP DynFlags)
unrecognisedWarning [Char]
"fwarn-"),
      (Deprecation
Deprecated,    [Char] -> Flag (CmdLineP DynFlags)
unrecognisedWarning [Char]
"fno-warn-") ]
 forall a. [a] -> [a] -> [a]
++ [ DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Werror=compat"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setWErrorFlag [WarningFlag]
minusWcompatOpts))
    , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wno-error=compat"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetFatalWarningFlag [WarningFlag]
minusWcompatOpts))
    , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wwarn=compat"
        (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetFatalWarningFlag [WarningFlag]
minusWcompatOpts)) ]
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"f"         Extension -> DynP ()
setExtensionFlag  ) [(Deprecation, FlagSpec Extension)]
fLangFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"fno-"      Extension -> DynP ()
unSetExtensionFlag) [(Deprecation, FlagSpec Extension)]
fLangFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"X"         Extension -> DynP ()
setExtensionFlag  ) [(Deprecation, FlagSpec Extension)]
xFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOff [Char]
"XNo"       Extension -> DynP ()
unSetExtensionFlag) [(Deprecation, FlagSpec Extension)]
xFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"X"         Language -> DynP ()
setLanguage       ) [(Deprecation, FlagSpec Language)]
languageFlagsDeps
 forall a. [a] -> [a] -> [a]
++ forall a b. (a -> b) -> [a] -> [b]
map (forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turnOn  [Char]
"X"         SafeHaskellMode -> DynP ()
setSafeHaskell    ) [(Deprecation, FlagSpec SafeHaskellMode)]
safeHaskellFlagsDeps

-- | This is where we handle unrecognised warning flags. We only issue a warning
-- if -Wunrecognised-warning-flags is set. See #11429 for context.
unrecognisedWarning :: String -> Flag (CmdLineP DynFlags)
unrecognisedWarning :: [Char] -> Flag (CmdLineP DynFlags)
unrecognisedWarning [Char]
prefix = forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defHiddenFlag [Char]
prefix (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix [Char] -> DynP ()
action)
  where
    action :: String -> EwM (CmdLineP DynFlags) ()
    action :: [Char] -> DynP ()
action [Char]
flag = do
      Bool
f <- WarningFlag -> DynFlags -> Bool
wopt WarningFlag
Opt_WarnUnrecognisedWarningFlags forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM forall s. CmdLineP s s
getCmdLineState
      forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
f forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *).
Monad m =>
DiagnosticReason -> [Char] -> EwM m ()
addFlagWarn (WarningFlag -> DiagnosticReason
WarningWithFlag WarningFlag
Opt_WarnUnrecognisedWarningFlags) forall a b. (a -> b) -> a -> b
$
        [Char]
"unrecognised warning flag: -" forall a. [a] -> [a] -> [a]
++ [Char]
prefix forall a. [a] -> [a] -> [a]
++ [Char]
flag

-- See Note [Supporting CLI completion]
package_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]
package_flags_deps :: [(Deprecation, Flag (CmdLineP DynFlags))]
package_flags_deps = [
        ------- Packages ----------------------------------------------------
    DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"package-db"
      (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (PkgDbRef -> DynP ()
addPkgDbRef forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> PkgDbRef
PkgDbPath))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"clear-package-db"      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
clearPkgDb)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"no-global-package-db"  (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeGlobalPkgDb)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"no-user-package-db"    (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeUserPkgDb)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"global-package-db"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (PkgDbRef -> DynP ()
addPkgDbRef PkgDbRef
GlobalPkgDb))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"user-package-db"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (PkgDbRef -> DynP ()
addPkgDbRef PkgDbRef
UserPkgDb))
    -- backwards compat with GHC<=7.4 :
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"package-conf"
      (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg forall a b. (a -> b) -> a -> b
$ PkgDbRef -> DynP ()
addPkgDbRef forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> PkgDbRef
PkgDbPath) [Char]
"Use -package-db instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"no-user-package-conf"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
removeUserPkgDb)              [Char]
"Use -no-user-package-db instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"package-name"       (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg forall a b. (a -> b) -> a -> b
$ \[Char]
name ->
                                      (DynFlags -> DynFlags) -> DynP ()
upd ([Char] -> DynFlags -> DynFlags
setUnitId [Char]
name))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"this-unit-id"       (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setUnitId)

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"working-dir"       (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setWorkingDirectory)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"this-package-name"  (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setPackageName)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hidden-module"      (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
addHiddenModule)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"reexported-module"  (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
addReexportedModule)

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"package"               (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
exposePackage)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"plugin-package-id"     (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
exposePluginPackageId)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"plugin-package"        (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
exposePluginPackage)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"package-id"            (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
exposePackageId)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"hide-package"          (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
hidePackage)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"hide-all-packages"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_HideAllPackages))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"hide-all-plugin-packages"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_HideAllPluginPackages))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"package-env"           (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
setPackageEnv)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"ignore-package"        (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
ignorePackage)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"syslib" (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
exposePackage) [Char]
"Use -package instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"distrust-all-packages"
      (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DistrustAllPackages))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"trust"                 (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
trustPackage)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"distrust"              (forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
distrustPackage)
  ]
  where
    setPackageEnv :: [Char] -> DynP ()
setPackageEnv [Char]
env = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
s -> DynFlags
s { packageEnv :: Maybe [Char]
packageEnv = forall a. a -> Maybe a
Just [Char]
env }

-- | Make a list of flags for shell completion.
-- Filter all available flags into two groups, for interactive GHC vs all other.
flagsForCompletion :: Bool -> [String]
flagsForCompletion :: Bool -> [[Char]]
flagsForCompletion Bool
isInteractive
    = [ Char
'-'forall a. a -> [a] -> [a]
:forall (m :: * -> *). Flag m -> [Char]
flagName Flag (CmdLineP DynFlags)
flag
      | Flag (CmdLineP DynFlags)
flag <- [Flag (CmdLineP DynFlags)]
flagsAll
      , GhcFlagMode -> Bool
modeFilter (forall (m :: * -> *). Flag m -> GhcFlagMode
flagGhcMode Flag (CmdLineP DynFlags)
flag)
      ]
    where
      modeFilter :: GhcFlagMode -> Bool
modeFilter GhcFlagMode
AllModes = Bool
True
      modeFilter GhcFlagMode
OnlyGhci = Bool
isInteractive
      modeFilter GhcFlagMode
OnlyGhc = Bool -> Bool
not Bool
isInteractive
      modeFilter GhcFlagMode
HiddenFlag = Bool
False

type TurnOnFlag = Bool   -- True  <=> we are turning the flag on
                         -- False <=> we are turning the flag off
turnOn  :: TurnOnFlag; turnOn :: Bool
turnOn  = Bool
True
turnOff :: TurnOnFlag; turnOff :: Bool
turnOff = Bool
False

data FlagSpec flag
   = FlagSpec
       { forall flag. FlagSpec flag -> [Char]
flagSpecName :: String   -- ^ Flag in string form
       , forall flag. FlagSpec flag -> flag
flagSpecFlag :: flag     -- ^ Flag in internal form
       , forall flag. FlagSpec flag -> Bool -> DynP ()
flagSpecAction :: (TurnOnFlag -> DynP ())
           -- ^ Extra action to run when the flag is found
           -- Typically, emit a warning or error
       , forall flag. FlagSpec flag -> GhcFlagMode
flagSpecGhcMode :: GhcFlagMode
           -- ^ In which ghc mode the flag has effect
       }

-- | Define a new flag.
flagSpec :: String -> flag -> (Deprecation, FlagSpec flag)
flagSpec :: forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
name flag
flag = forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
name flag
flag Bool -> DynP ()
nop

-- | Define a new flag with an effect.
flagSpec' :: String -> flag -> (TurnOnFlag -> DynP ())
          -> (Deprecation, FlagSpec flag)
flagSpec' :: forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
name flag
flag Bool -> DynP ()
act = (Deprecation
NotDeprecated, forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name flag
flag Bool -> DynP ()
act GhcFlagMode
AllModes)

-- | Define a warning flag.
warnSpec :: WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec :: WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
flag = WarningFlag
-> (Bool -> DynP ()) -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec' WarningFlag
flag Bool -> DynP ()
nop

-- | Define a warning flag with an effect.
warnSpec' :: WarningFlag -> (TurnOnFlag -> DynP ())
          -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec' :: WarningFlag
-> (Bool -> DynP ()) -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec' WarningFlag
flag Bool -> DynP ()
act = [ (Deprecation
NotDeprecated, forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name WarningFlag
flag Bool -> DynP ()
act GhcFlagMode
AllModes)
                     | [Char]
name <- forall a. NonEmpty a -> [a]
NE.toList (WarningFlag -> NonEmpty [Char]
warnFlagNames WarningFlag
flag)
                     ]

-- | Define a new deprecated flag with an effect.
depFlagSpecOp :: String -> flag -> (TurnOnFlag -> DynP ()) -> String
            -> (Deprecation, FlagSpec flag)
depFlagSpecOp :: forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> [Char]
-> (Deprecation, FlagSpec flag)
depFlagSpecOp [Char]
name flag
flag Bool -> DynP ()
act [Char]
dep =
    (Deprecation
Deprecated, forall a b. (a, b) -> b
snd (forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
name flag
flag (\Bool
f -> Bool -> DynP ()
act Bool
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
dep)))

-- | Define a new deprecated flag.
depFlagSpec :: String -> flag -> String
            -> (Deprecation, FlagSpec flag)
depFlagSpec :: forall flag.
[Char] -> flag -> [Char] -> (Deprecation, FlagSpec flag)
depFlagSpec [Char]
name flag
flag [Char]
dep = forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> [Char]
-> (Deprecation, FlagSpec flag)
depFlagSpecOp [Char]
name flag
flag Bool -> DynP ()
nop [Char]
dep

-- | Define a deprecated warning flag.
depWarnSpec :: WarningFlag -> String
            -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec :: WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
flag [Char]
dep = [ forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> [Char]
-> (Deprecation, FlagSpec flag)
depFlagSpecOp [Char]
name WarningFlag
flag Bool -> DynP ()
nop [Char]
dep
                       | [Char]
name <- forall a. NonEmpty a -> [a]
NE.toList (WarningFlag -> NonEmpty [Char]
warnFlagNames WarningFlag
flag)
                       ]

-- | Define a deprecated warning name substituted by another.
subWarnSpec :: String -> WarningFlag -> String
            -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec :: [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
oldname WarningFlag
flag [Char]
dep = [ forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> [Char]
-> (Deprecation, FlagSpec flag)
depFlagSpecOp [Char]
oldname WarningFlag
flag Bool -> DynP ()
nop [Char]
dep ]


-- | Define a new deprecated flag with an effect where the deprecation message
-- depends on the flag value
depFlagSpecOp' :: String
             -> flag
             -> (TurnOnFlag -> DynP ())
             -> (TurnOnFlag -> String)
             -> (Deprecation, FlagSpec flag)
depFlagSpecOp' :: forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> (Bool -> [Char])
-> (Deprecation, FlagSpec flag)
depFlagSpecOp' [Char]
name flag
flag Bool -> DynP ()
act Bool -> [Char]
dep =
    (Deprecation
Deprecated, forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name flag
flag (\Bool
f -> Bool -> DynP ()
act Bool
f forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate forall a b. (a -> b) -> a -> b
$ Bool -> [Char]
dep Bool
f))
                                                                       GhcFlagMode
AllModes)

-- | Define a new deprecated flag where the deprecation message
-- depends on the flag value
depFlagSpec' :: String
             -> flag
             -> (TurnOnFlag -> String)
             -> (Deprecation, FlagSpec flag)
depFlagSpec' :: forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
name flag
flag Bool -> [Char]
dep = forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> (Bool -> [Char])
-> (Deprecation, FlagSpec flag)
depFlagSpecOp' [Char]
name flag
flag Bool -> DynP ()
nop Bool -> [Char]
dep


-- | Define a new deprecated flag where the deprecation message
-- is shown depending on the flag value
depFlagSpecCond :: String
                -> flag
                -> (TurnOnFlag -> Bool)
                -> String
                -> (Deprecation, FlagSpec flag)
depFlagSpecCond :: forall flag.
[Char]
-> flag -> (Bool -> Bool) -> [Char] -> (Deprecation, FlagSpec flag)
depFlagSpecCond [Char]
name flag
flag Bool -> Bool
cond [Char]
dep =
    (Deprecation
Deprecated, forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name flag
flag (\Bool
f -> forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (Bool -> Bool
cond Bool
f) forall a b. (a -> b) -> a -> b
$ forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
dep)
                                                                       GhcFlagMode
AllModes)

-- | Define a new flag for GHCi.
flagGhciSpec :: String -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec :: forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
name flag
flag = forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagGhciSpec' [Char]
name flag
flag Bool -> DynP ()
nop

-- | Define a new flag for GHCi with an effect.
flagGhciSpec' :: String -> flag -> (TurnOnFlag -> DynP ())
              -> (Deprecation, FlagSpec flag)
flagGhciSpec' :: forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagGhciSpec' [Char]
name flag
flag Bool -> DynP ()
act = (Deprecation
NotDeprecated, forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name flag
flag Bool -> DynP ()
act GhcFlagMode
OnlyGhci)

-- | Define a new flag invisible to CLI completion.
flagHiddenSpec :: String -> flag -> (Deprecation, FlagSpec flag)
flagHiddenSpec :: forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagHiddenSpec [Char]
name flag
flag = forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagHiddenSpec' [Char]
name flag
flag Bool -> DynP ()
nop

-- | Define a new flag invisible to CLI completion with an effect.
flagHiddenSpec' :: String -> flag -> (TurnOnFlag -> DynP ())
                -> (Deprecation, FlagSpec flag)
flagHiddenSpec' :: forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagHiddenSpec' [Char]
name flag
flag Bool -> DynP ()
act = (Deprecation
NotDeprecated, forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name flag
flag Bool -> DynP ()
act
                                                                     GhcFlagMode
HiddenFlag)

-- | Hide a 'FlagSpec' from being displayed in @--show-options@.
--
-- This is for example useful for flags that are obsolete, but should not
-- (yet) be deprecated for compatibility reasons.
hideFlag :: (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag :: forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag (Deprecation
dep, FlagSpec a
fs) = (Deprecation
dep, FlagSpec a
fs { flagSpecGhcMode :: GhcFlagMode
flagSpecGhcMode = GhcFlagMode
HiddenFlag })

mkFlag :: TurnOnFlag            -- ^ True <=> it should be turned on
       -> String                -- ^ The flag prefix
       -> (flag -> DynP ())     -- ^ What to do when the flag is found
       -> (Deprecation, FlagSpec flag)  -- ^ Specification of
                                        -- this particular flag
       -> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag :: forall flag.
Bool
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag Bool
turn_on [Char]
flagPrefix flag -> DynP ()
f (Deprecation
dep, (FlagSpec [Char]
name flag
flag Bool -> DynP ()
extra_action GhcFlagMode
mode))
    = (Deprecation
dep,
       forall (m :: * -> *). [Char] -> OptKind m -> GhcFlagMode -> Flag m
Flag ([Char]
flagPrefix forall a. [a] -> [a] -> [a]
++ [Char]
name) (forall (m :: * -> *). EwM m () -> OptKind m
NoArg (flag -> DynP ()
f flag
flag forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> Bool -> DynP ()
extra_action Bool
turn_on)) GhcFlagMode
mode)

-- here to avoid module cycle with GHC.Driver.CmdLine
deprecate :: Monad m => String -> EwM m ()
deprecate :: forall (m :: * -> *). Monad m => [Char] -> EwM m ()
deprecate [Char]
s = do
    [Char]
arg <- forall (m :: * -> *). Monad m => EwM m [Char]
getArg
    forall (m :: * -> *).
Monad m =>
DiagnosticReason -> [Char] -> EwM m ()
addFlagWarn (WarningFlag -> DiagnosticReason
WarningWithFlag WarningFlag
Opt_WarnDeprecatedFlags) ([Char]
arg forall a. [a] -> [a] -> [a]
++ [Char]
" is deprecated: " forall a. [a] -> [a] -> [a]
++ [Char]
s)

deprecatedForExtension :: String -> TurnOnFlag -> String
deprecatedForExtension :: [Char] -> Bool -> [Char]
deprecatedForExtension [Char]
lang Bool
turn_on
    = [Char]
"use -X" forall a. [a] -> [a] -> [a]
++ [Char]
flag forall a. [a] -> [a] -> [a]
++
      [Char]
" or pragma {-# LANGUAGE " forall a. [a] -> [a] -> [a]
++ [Char]
flag forall a. [a] -> [a] -> [a]
++ [Char]
" #-} instead"
    where
      flag :: [Char]
flag | Bool
turn_on   = [Char]
lang
           | Bool
otherwise = [Char]
"No" forall a. [a] -> [a] -> [a]
++ [Char]
lang

deprecatedForExtensions :: [String] -> TurnOnFlag -> String
deprecatedForExtensions :: [[Char]] -> Bool -> [Char]
deprecatedForExtensions [] Bool
_ = forall a. HasCallStack => [Char] -> a
panic [Char]
"new extension has not been specified"
deprecatedForExtensions [[Char]
lang] Bool
turn_on = [Char] -> Bool -> [Char]
deprecatedForExtension [Char]
lang Bool
turn_on
deprecatedForExtensions [[Char]]
langExts Bool
turn_on
    = [Char]
"use " forall a. [a] -> [a] -> [a]
++ [[Char]] -> [Char]
xExt [[Char]]
flags forall a. [a] -> [a] -> [a]
++ [Char]
" instead"
    where
      flags :: [[Char]]
flags | Bool
turn_on = [[Char]]
langExts
            | Bool
otherwise = ([Char]
"No" forall a. [a] -> [a] -> [a]
++) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
langExts

      xExt :: [[Char]] -> [Char]
xExt [[Char]]
fls = forall a. [a] -> [[a]] -> [a]
intercalate [Char]
" and "  forall a b. (a -> b) -> a -> b
$ (\[Char]
flag -> [Char]
"-X" forall a. [a] -> [a] -> [a]
++ [Char]
flag) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [[Char]]
fls

useInstead :: String -> String -> TurnOnFlag -> String
useInstead :: [Char] -> [Char] -> Bool -> [Char]
useInstead [Char]
prefix [Char]
flag Bool
turn_on
  = [Char]
"Use " forall a. [a] -> [a] -> [a]
++ [Char]
prefix forall a. [a] -> [a] -> [a]
++ [Char]
no forall a. [a] -> [a] -> [a]
++ [Char]
flag forall a. [a] -> [a] -> [a]
++ [Char]
" instead"
  where
    no :: [Char]
no = if Bool
turn_on then [Char]
"" else [Char]
"no-"

nop :: TurnOnFlag -> DynP ()
nop :: Bool -> DynP ()
nop Bool
_ = forall (m :: * -> *) a. Monad m => a -> m a
return ()

-- | Find the 'FlagSpec' for a 'WarningFlag'.
flagSpecOf :: WarningFlag -> Maybe (FlagSpec WarningFlag)
flagSpecOf :: WarningFlag -> Maybe (FlagSpec WarningFlag)
flagSpecOf = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Map WarningFlag (FlagSpec WarningFlag)
wWarningFlagMap

wWarningFlagMap :: Map.Map WarningFlag (FlagSpec WarningFlag)
wWarningFlagMap :: Map WarningFlag (FlagSpec WarningFlag)
wWarningFlagMap = forall k a. Ord k => (a -> a -> a) -> [(k, a)] -> Map k a
Map.fromListWith (\FlagSpec WarningFlag
_ FlagSpec WarningFlag
x -> FlagSpec WarningFlag
x) forall a b. (a -> b) -> a -> b
$ forall a b. (a -> b) -> [a] -> [b]
map (forall flag. FlagSpec flag -> flag
flagSpecFlag forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&& forall a. a -> a
id) [FlagSpec WarningFlag]
wWarningFlags

-- | These @-W\<blah\>@ flags can all be reversed with @-Wno-\<blah\>@
wWarningFlags :: [FlagSpec WarningFlag]
wWarningFlags :: [FlagSpec WarningFlag]
wWarningFlags = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd (forall a. (a -> a -> Ordering) -> [a] -> [a]
sortBy (forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing forall a b. (a, b) -> a
fst) [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps)

wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps = forall a. Monoid a => [a] -> a
mconcat [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
-- Please keep the list of flags below sorted alphabetically
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnAlternativeLayoutRuleTransitional,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnAmbiguousFields,
  WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
Opt_WarnAutoOrphans
              [Char]
"it has no effect",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnCPPUndef,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnbangedStrictPatterns,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDeferredTypeErrors,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDeferredOutOfScopeVariables,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnWarningsDeprecations,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDeprecatedFlags,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDerivingDefaults,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDerivingTypeable,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDodgyExports,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDodgyForeignImports,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDodgyImports,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnEmptyEnumerations,
  [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
"duplicate-constraints"
              WarningFlag
Opt_WarnDuplicateConstraints
              [Char]
"it is subsumed by -Wredundant-constraints",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnRedundantConstraints,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnDuplicateExports,
  WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
Opt_WarnHiShadows
              [Char]
"it is not used, and was never implemented",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnInaccessibleCode,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnImplicitPrelude,
  WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
Opt_WarnImplicitKindVars
              [Char]
"it is now an error",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnIncompletePatterns,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnIncompletePatternsRecUpd,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnIncompleteUniPatterns,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnInlineRuleShadowing,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnIdentities,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingFields,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingImportList,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingExportList,
  [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
"missing-local-sigs"
              WarningFlag
Opt_WarnMissingLocalSignatures
              [Char]
"it is replaced by -Wmissing-local-signatures",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingLocalSignatures,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingMethods,
  WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
Opt_WarnMissingMonadFailInstances
              [Char]
"fail is no longer a method of Monad",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnSemigroup,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingSignatures,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingKindSignatures,
  [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
"missing-exported-sigs"
              WarningFlag
Opt_WarnMissingExportedSignatures
              [Char]
"it is replaced by -Wmissing-exported-signatures",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingExportedSignatures,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMonomorphism,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnNameShadowing,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnNonCanonicalMonadInstances,
  WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
Opt_WarnNonCanonicalMonadFailInstances
              [Char]
"fail is no longer a method of Monad",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnNonCanonicalMonoidInstances,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnOrphans,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnOverflowedLiterals,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnOverlappingPatterns,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissedSpecs,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnAllMissedSpecs,
  WarningFlag
-> (Bool -> DynP ()) -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec'   WarningFlag
Opt_WarnSafe Bool -> DynP ()
setWarnSafe,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnTrustworthySafe,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnInferredSafeImports,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingSafeHaskellMode,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnTabs,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnTypeDefaults,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnTypedHoles,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnPartialTypeSignatures,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnrecognisedPragmas,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMisplacedPragmas,
  WarningFlag
-> (Bool -> DynP ()) -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec'   WarningFlag
Opt_WarnUnsafe Bool -> DynP ()
setWarnUnsafe,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnsupportedCallingConventions,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnsupportedLlvmVersion,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissedExtraSharedLib,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUntickedPromotedConstructors,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedDoBind,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedForalls,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedImports,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedLocalBinds,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedMatches,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedPatternBinds,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedTopBinds,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedTypePatterns,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedRecordWildcards,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnRedundantBangPatterns,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnRedundantRecordWildcards,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnRedundantStrictnessFlags,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnWrongDoBind,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingPatternSynonymSignatures,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingDerivingStrategies,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnSimplifiableClassConstraints,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingHomeModules,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnrecognisedWarningFlags,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnStarBinder,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnStarIsType,
  WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
Opt_WarnSpaceAfterBang
              [Char]
"bang patterns can no longer be written with a space",
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnPartialFields,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnPrepositiveQualifiedModule,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnusedPackages,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnCompatUnqualifiedImports,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnInvalidHaddock,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnOperatorWhitespaceExtConflict,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnOperatorWhitespace,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnImplicitLift,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnMissingExportedPatternSynonymSignatures,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnForallIdentifier,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnUnicodeBidirectionalFormatCharacters,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnGADTMonoLocalBinds,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnTypeEqualityOutOfScope,
  WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec    WarningFlag
Opt_WarnTypeEqualityRequiresOperators
 ]

-- | These @-\<blah\>@ flags can all be reversed with @-no-\<blah\>@
negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps = [
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"ignore-dot-ghci"         GeneralFlag
Opt_IgnoreDotGhci ]

-- | These @-d\<blah\>@ flags can all be reversed with @-dno-\<blah\>@
dFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
dFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
dFlagsDeps = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
-- Please keep the list of flags below sorted alphabetically
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ppr-case-as-let"            GeneralFlag
Opt_PprCaseAsLet,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"ppr-ticks"              GeneralFlag
Opt_PprShowTicks
     (\Bool
turn_on -> [Char] -> [Char] -> Bool -> [Char]
useInstead [Char]
"-d" [Char]
"suppress-ticks" (Bool -> Bool
not Bool
turn_on)),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-ticks"             GeneralFlag
Opt_SuppressTicks,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"suppress-stg-free-vars" GeneralFlag
Opt_SuppressStgExts
     ([Char] -> [Char] -> Bool -> [Char]
useInstead [Char]
"-d" [Char]
"suppress-stg-exts"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-stg-exts"          GeneralFlag
Opt_SuppressStgExts,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-stg-reps"          GeneralFlag
Opt_SuppressStgReps,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-coercions"         GeneralFlag
Opt_SuppressCoercions,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-coercion-types"    GeneralFlag
Opt_SuppressCoercionTypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-idinfo"            GeneralFlag
Opt_SuppressIdInfo,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-unfoldings"        GeneralFlag
Opt_SuppressUnfoldings,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-module-prefixes"   GeneralFlag
Opt_SuppressModulePrefixes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-timestamps"        GeneralFlag
Opt_SuppressTimestamps,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-type-applications" GeneralFlag
Opt_SuppressTypeApplications,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-type-signatures"   GeneralFlag
Opt_SuppressTypeSignatures,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-uniques"           GeneralFlag
Opt_SuppressUniques,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-var-kinds"         GeneralFlag
Opt_SuppressVarKinds,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"suppress-core-sizes"        GeneralFlag
Opt_SuppressCoreSizes
  ]

-- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
fFlags :: [FlagSpec GeneralFlag]
fFlags :: [FlagSpec GeneralFlag]
fFlags = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps

fFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps :: [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
-- Please keep the list of flags below sorted alphabetically
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"asm-shortcutting"                 GeneralFlag
Opt_AsmShortcutting,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"break-on-error"               GeneralFlag
Opt_BreakOnError,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"break-on-exception"           GeneralFlag
Opt_BreakOnException,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"building-cabal-package"           GeneralFlag
Opt_BuildingCabalPackage,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"call-arity"                       GeneralFlag
Opt_CallArity,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"exitification"                    GeneralFlag
Opt_Exitification,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"case-merge"                       GeneralFlag
Opt_CaseMerge,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"case-folding"                     GeneralFlag
Opt_CaseFolding,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cmm-elim-common-blocks"           GeneralFlag
Opt_CmmElimCommonBlocks,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cmm-sink"                         GeneralFlag
Opt_CmmSink,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cmm-static-pred"                  GeneralFlag
Opt_CmmStaticPred,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cse"                              GeneralFlag
Opt_CSE,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"stg-cse"                          GeneralFlag
Opt_StgCSE,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"stg-lift-lams"                    GeneralFlag
Opt_StgLiftLams,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cpr-anal"                         GeneralFlag
Opt_CprAnal,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"defer-diagnostics"                GeneralFlag
Opt_DeferDiagnostics,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"defer-type-errors"                GeneralFlag
Opt_DeferTypeErrors,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"defer-typed-holes"                GeneralFlag
Opt_DeferTypedHoles,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"defer-out-of-scope-variables"     GeneralFlag
Opt_DeferOutOfScopeVariables,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"diagnostics-show-caret"           GeneralFlag
Opt_DiagnosticsShowCaret,
  -- With-ways needs to be reversible hence why its made via flagSpec unlike
  -- other debugging flags.
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"dump-with-ways"                   GeneralFlag
Opt_DumpWithWays,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"dicts-cheap"                      GeneralFlag
Opt_DictsCheap,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"dicts-strict"                     GeneralFlag
Opt_DictsStrict,
  forall flag.
[Char] -> flag -> [Char] -> (Deprecation, FlagSpec flag)
depFlagSpec [Char]
"dmd-tx-dict-sel"
      GeneralFlag
Opt_DmdTxDictSel [Char]
"effect is now unconditionally enabled",
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"do-eta-reduction"                 GeneralFlag
Opt_DoEtaReduction,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"do-lambda-eta-expansion"          GeneralFlag
Opt_DoLambdaEtaExpansion,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"eager-blackholing"                GeneralFlag
Opt_EagerBlackHoling,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"embed-manifest"                   GeneralFlag
Opt_EmbedManifest,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"enable-rewrite-rules"             GeneralFlag
Opt_EnableRewriteRules,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"enable-th-splice-warnings"        GeneralFlag
Opt_EnableThSpliceWarnings,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"error-spans"                      GeneralFlag
Opt_ErrorSpans,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"excess-precision"                 GeneralFlag
Opt_ExcessPrecision,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"expose-all-unfoldings"            GeneralFlag
Opt_ExposeAllUnfoldings,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"expose-internal-symbols"          GeneralFlag
Opt_ExposeInternalSymbols,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"external-dynamic-refs"            GeneralFlag
Opt_ExternalDynamicRefs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"external-interpreter"             GeneralFlag
Opt_ExternalInterpreter,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"family-application-cache"         GeneralFlag
Opt_FamAppCache,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"float-in"                         GeneralFlag
Opt_FloatIn,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"force-recomp"                     GeneralFlag
Opt_ForceRecomp,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ignore-optim-changes"             GeneralFlag
Opt_IgnoreOptimChanges,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ignore-hpc-changes"               GeneralFlag
Opt_IgnoreHpcChanges,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"full-laziness"                    GeneralFlag
Opt_FullLaziness,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"fun-to-thunk"                 GeneralFlag
Opt_FunToThunk
      ([Char] -> [Char] -> Bool -> [Char]
useInstead [Char]
"-f" [Char]
"full-laziness"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"local-float-out"                  GeneralFlag
Opt_LocalFloatOut,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"local-float-out-top-level"        GeneralFlag
Opt_LocalFloatOutTopLevel,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"gen-manifest"                     GeneralFlag
Opt_GenManifest,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ghci-history"                     GeneralFlag
Opt_GhciHistory,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ghci-leak-check"                  GeneralFlag
Opt_GhciLeakCheck,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"validate-ide-info"                GeneralFlag
Opt_ValidateHie,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"local-ghci-history"           GeneralFlag
Opt_LocalGhciHistory,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"no-it"                        GeneralFlag
Opt_NoIt,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ghci-sandbox"                     GeneralFlag
Opt_GhciSandbox,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"helpful-errors"                   GeneralFlag
Opt_HelpfulErrors,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"hpc"                              GeneralFlag
Opt_Hpc,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ignore-asserts"                   GeneralFlag
Opt_IgnoreAsserts,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ignore-interface-pragmas"         GeneralFlag
Opt_IgnoreInterfacePragmas,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"implicit-import-qualified"    GeneralFlag
Opt_ImplicitImportQualified,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"irrefutable-tuples"               GeneralFlag
Opt_IrrefutableTuples,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"keep-going"                       GeneralFlag
Opt_KeepGoing,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"late-dmd-anal"                    GeneralFlag
Opt_LateDmdAnal,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"late-specialise"                  GeneralFlag
Opt_LateSpecialise,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"liberate-case"                    GeneralFlag
Opt_LiberateCase,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagHiddenSpec [Char]
"llvm-tbaa"                  GeneralFlag
Opt_LlvmTBAA,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagHiddenSpec [Char]
"llvm-fill-undef-with-garbage" GeneralFlag
Opt_LlvmFillUndefWithGarbage,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"loopification"                    GeneralFlag
Opt_Loopification,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"block-layout-cfg"                 GeneralFlag
Opt_CfgBlocklayout,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"block-layout-weightless"          GeneralFlag
Opt_WeightlessBlocklayout,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"omit-interface-pragmas"           GeneralFlag
Opt_OmitInterfacePragmas,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"omit-yields"                      GeneralFlag
Opt_OmitYields,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"optimal-applicative-do"           GeneralFlag
Opt_OptimalApplicativeDo,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"pedantic-bottoms"                 GeneralFlag
Opt_PedanticBottoms,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"pre-inlining"                     GeneralFlag
Opt_SimplPreInlining,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"print-bind-contents"          GeneralFlag
Opt_PrintBindContents,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"print-bind-result"            GeneralFlag
Opt_PrintBindResult,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagGhciSpec [Char]
"print-evld-with-show"         GeneralFlag
Opt_PrintEvldWithShow,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-explicit-foralls"           GeneralFlag
Opt_PrintExplicitForalls,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-explicit-kinds"             GeneralFlag
Opt_PrintExplicitKinds,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-explicit-coercions"         GeneralFlag
Opt_PrintExplicitCoercions,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-explicit-runtime-reps"      GeneralFlag
Opt_PrintExplicitRuntimeReps,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-equality-relations"         GeneralFlag
Opt_PrintEqualityRelations,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-axiom-incomps"              GeneralFlag
Opt_PrintAxiomIncomps,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-unicode-syntax"             GeneralFlag
Opt_PrintUnicodeSyntax,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-expanded-synonyms"          GeneralFlag
Opt_PrintExpandedSynonyms,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-potential-instances"        GeneralFlag
Opt_PrintPotentialInstances,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-redundant-promotion-ticks"  GeneralFlag
Opt_PrintRedundantPromotionTicks,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"print-typechecker-elaboration"    GeneralFlag
Opt_PrintTypecheckerElaboration,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"prof-cafs"                        GeneralFlag
Opt_AutoSccsOnIndividualCafs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"prof-count-entries"               GeneralFlag
Opt_ProfCountEntries,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"prof-late"                        GeneralFlag
Opt_ProfLateCcs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"prof-manual"                      GeneralFlag
Opt_ProfManualCcs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"prof-late-inline"                 GeneralFlag
Opt_ProfLateInlineCcs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"regs-graph"                       GeneralFlag
Opt_RegsGraph,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"regs-iterative"                   GeneralFlag
Opt_RegsIterative,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"rewrite-rules"                GeneralFlag
Opt_EnableRewriteRules
   ([Char] -> [Char] -> Bool -> [Char]
useInstead [Char]
"-f" [Char]
"enable-rewrite-rules"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"shared-implib"                    GeneralFlag
Opt_SharedImplib,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"spec-constr"                      GeneralFlag
Opt_SpecConstr,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"spec-constr-keen"                 GeneralFlag
Opt_SpecConstrKeen,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"specialise"                       GeneralFlag
Opt_Specialise,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"specialize"                       GeneralFlag
Opt_Specialise,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"specialise-aggressively"          GeneralFlag
Opt_SpecialiseAggressively,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"specialize-aggressively"          GeneralFlag
Opt_SpecialiseAggressively,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cross-module-specialise"          GeneralFlag
Opt_CrossModuleSpecialise,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cross-module-specialize"          GeneralFlag
Opt_CrossModuleSpecialise,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"inline-generics"                  GeneralFlag
Opt_InlineGenerics,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"inline-generics-aggressively"     GeneralFlag
Opt_InlineGenericsAggressively,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"static-argument-transformation"   GeneralFlag
Opt_StaticArgumentTransformation,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"strictness"                       GeneralFlag
Opt_Strictness,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"use-rpaths"                       GeneralFlag
Opt_RPath,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"write-interface"                  GeneralFlag
Opt_WriteInterface,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"write-if-simplified-core"         GeneralFlag
Opt_WriteIfSimplifiedCore,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"write-ide-info"                   GeneralFlag
Opt_WriteHie,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"unbox-small-strict-fields"        GeneralFlag
Opt_UnboxSmallStrictFields,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"unbox-strict-fields"              GeneralFlag
Opt_UnboxStrictFields,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"version-macros"                   GeneralFlag
Opt_VersionMacros,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"worker-wrapper"                   GeneralFlag
Opt_WorkerWrapper,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"worker-wrapper-cbv"               GeneralFlag
Opt_WorkerWrapperUnlift, -- See Note [Worker/wrapper for strict arguments]
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"solve-constant-dicts"             GeneralFlag
Opt_SolveConstantDicts,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"catch-nonexhaustive-cases"        GeneralFlag
Opt_CatchNonexhaustiveCases,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"alignment-sanitisation"           GeneralFlag
Opt_AlignmentSanitisation,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"check-prim-bounds"                GeneralFlag
Opt_DoBoundsChecking,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"num-constant-folding"             GeneralFlag
Opt_NumConstantFolding,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"core-constant-folding"            GeneralFlag
Opt_CoreConstantFolding,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"fast-pap-calls"                   GeneralFlag
Opt_FastPAPCalls,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cmm-control-flow"                 GeneralFlag
Opt_CmmControlFlow,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-warning-groups"              GeneralFlag
Opt_ShowWarnGroups,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"hide-source-paths"                GeneralFlag
Opt_HideSourcePaths,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-loaded-modules"              GeneralFlag
Opt_ShowLoadedModules,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"whole-archive-hs-libs"            GeneralFlag
Opt_WholeArchiveHsLibs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"keep-cafs"                        GeneralFlag
Opt_KeepCAFs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"link-rts"                         GeneralFlag
Opt_LinkRts,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"byte-code-and-object-code"        GeneralFlag
Opt_ByteCodeAndObjectCode,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"prefer-byte-code"                 GeneralFlag
Opt_UseBytecodeRatherThanObjects,
  forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
"compact-unwind"                  GeneralFlag
Opt_CompactUnwind
      (\Bool
turn_on -> (DynFlags -> DynP DynFlags) -> DynP ()
updM (\DynFlags
dflags -> do
        forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
unless (Platform -> OS
platformOS (DynFlags -> Platform
targetPlatform DynFlags
dflags) forall a. Eq a => a -> a -> Bool
== OS
OSDarwin Bool -> Bool -> Bool
&& Bool
turn_on)
               (forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addWarn [Char]
"-compact-unwind is only implemented by the darwin platform. Ignoring.")
        forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags)),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-error-context"               GeneralFlag
Opt_ShowErrorContext,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"cmm-thread-sanitizer"             GeneralFlag
Opt_CmmThreadSanitizer,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"split-sections"                   GeneralFlag
Opt_SplitSections
  ]
  forall a. [a] -> [a] -> [a]
++ [(Deprecation, FlagSpec GeneralFlag)]
fHoleFlags

-- | These @-f\<blah\>@ flags have to do with the typed-hole error message or
-- the valid hole fits in that message. See Note [Valid hole fits include ...]
-- in the "GHC.Tc.Errors.Hole" module. These flags can all be reversed with
-- @-fno-\<blah\>@
fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)]
fHoleFlags :: [(Deprecation, FlagSpec GeneralFlag)]
fHoleFlags = [
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-hole-constraints"            GeneralFlag
Opt_ShowHoleConstraints,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"show-valid-substitutions"     GeneralFlag
Opt_ShowValidHoleFits
   ([Char] -> [Char] -> Bool -> [Char]
useInstead [Char]
"-f" [Char]
"show-valid-hole-fits"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-valid-hole-fits"             GeneralFlag
Opt_ShowValidHoleFits,
  -- Sorting settings
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"sort-valid-hole-fits"             GeneralFlag
Opt_SortValidHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"sort-by-size-hole-fits"           GeneralFlag
Opt_SortBySizeHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"sort-by-subsumption-hole-fits"    GeneralFlag
Opt_SortBySubsumHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"abstract-refinement-hole-fits"    GeneralFlag
Opt_AbstractRefHoleFits,
  -- Output format settings
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-hole-matches-of-hole-fits"   GeneralFlag
Opt_ShowMatchesOfHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-provenance-of-hole-fits"     GeneralFlag
Opt_ShowProvOfHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-type-of-hole-fits"           GeneralFlag
Opt_ShowTypeOfHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-type-app-of-hole-fits"       GeneralFlag
Opt_ShowTypeAppOfHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-type-app-vars-of-hole-fits"  GeneralFlag
Opt_ShowTypeAppVarsOfHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"show-docs-of-hole-fits"           GeneralFlag
Opt_ShowDocsOfHoleFits,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"unclutter-valid-hole-fits"        GeneralFlag
Opt_UnclutterValidHoleFits
  ]

-- | These @-f\<blah\>@ flags can all be reversed with @-fno-\<blah\>@
fLangFlags :: [FlagSpec LangExt.Extension]
fLangFlags :: [FlagSpec Extension]
fLangFlags = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [(Deprecation, FlagSpec Extension)]
fLangFlagsDeps

fLangFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]
fLangFlagsDeps :: [(Deprecation, FlagSpec Extension)]
fLangFlagsDeps = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
  forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> (Bool -> [Char])
-> (Deprecation, FlagSpec flag)
depFlagSpecOp' [Char]
"th"                           Extension
LangExt.TemplateHaskell
    Bool -> DynP ()
checkTemplateHaskellOk
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"TemplateHaskell"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"fi"                             Extension
LangExt.ForeignFunctionInterface
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ForeignFunctionInterface"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"ffi"                            Extension
LangExt.ForeignFunctionInterface
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ForeignFunctionInterface"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"arrows"                         Extension
LangExt.Arrows
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"Arrows"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"implicit-prelude"               Extension
LangExt.ImplicitPrelude
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ImplicitPrelude"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"bang-patterns"                  Extension
LangExt.BangPatterns
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"BangPatterns"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"monomorphism-restriction"       Extension
LangExt.MonomorphismRestriction
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"MonomorphismRestriction"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"extended-default-rules"         Extension
LangExt.ExtendedDefaultRules
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ExtendedDefaultRules"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"implicit-params"                Extension
LangExt.ImplicitParams
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ImplicitParams"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"scoped-type-variables"          Extension
LangExt.ScopedTypeVariables
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ScopedTypeVariables"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"allow-overlapping-instances"    Extension
LangExt.OverlappingInstances
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"OverlappingInstances"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"allow-undecidable-instances"    Extension
LangExt.UndecidableInstances
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"UndecidableInstances"),
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"allow-incoherent-instances"     Extension
LangExt.IncoherentInstances
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"IncoherentInstances")
  ]

supportedLanguages :: [String]
supportedLanguages :: [[Char]]
supportedLanguages = forall a b. (a -> b) -> [a] -> [b]
map (forall flag. FlagSpec flag -> [Char]
flagSpecName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Deprecation, FlagSpec Language)]
languageFlagsDeps

supportedLanguageOverlays :: [String]
supportedLanguageOverlays :: [[Char]]
supportedLanguageOverlays = forall a b. (a -> b) -> [a] -> [b]
map (forall flag. FlagSpec flag -> [Char]
flagSpecName forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a b. (a, b) -> b
snd) [(Deprecation, FlagSpec SafeHaskellMode)]
safeHaskellFlagsDeps

supportedExtensions :: ArchOS -> [String]
supportedExtensions :: ArchOS -> [[Char]]
supportedExtensions (ArchOS Arch
_ OS
os) = forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap FlagSpec Extension -> [[Char]]
toFlagSpecNamePair [FlagSpec Extension]
xFlags
  where
    toFlagSpecNamePair :: FlagSpec Extension -> [[Char]]
toFlagSpecNamePair FlagSpec Extension
flg
      -- IMPORTANT! Make sure that `ghc --supported-extensions` omits
      -- "TemplateHaskell"/"QuasiQuotes" when it's known not to work out of the
      -- box. See also GHC #11102 and #16331 for more details about
      -- the rationale
      | Bool
isAIX, forall flag. FlagSpec flag -> flag
flagSpecFlag FlagSpec Extension
flg forall a. Eq a => a -> a -> Bool
== Extension
LangExt.TemplateHaskell  = [[Char]
noName]
      | Bool
isAIX, forall flag. FlagSpec flag -> flag
flagSpecFlag FlagSpec Extension
flg forall a. Eq a => a -> a -> Bool
== Extension
LangExt.QuasiQuotes      = [[Char]
noName]
      | Bool
otherwise = [[Char]
name, [Char]
noName]
      where
        isAIX :: Bool
isAIX = OS
os forall a. Eq a => a -> a -> Bool
== OS
OSAIX
        noName :: [Char]
noName = [Char]
"No" forall a. [a] -> [a] -> [a]
++ [Char]
name
        name :: [Char]
name = forall flag. FlagSpec flag -> [Char]
flagSpecName FlagSpec Extension
flg

supportedLanguagesAndExtensions :: ArchOS -> [String]
supportedLanguagesAndExtensions :: ArchOS -> [[Char]]
supportedLanguagesAndExtensions ArchOS
arch_os =
    [[Char]]
supportedLanguages forall a. [a] -> [a] -> [a]
++ [[Char]]
supportedLanguageOverlays forall a. [a] -> [a] -> [a]
++ ArchOS -> [[Char]]
supportedExtensions ArchOS
arch_os

-- | These -X<blah> flags cannot be reversed with -XNo<blah>
languageFlagsDeps :: [(Deprecation, FlagSpec Language)]
languageFlagsDeps :: [(Deprecation, FlagSpec Language)]
languageFlagsDeps = [
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"Haskell98"   Language
Haskell98,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"Haskell2010" Language
Haskell2010,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"GHC2021"     Language
GHC2021
  ]

-- | These -X<blah> flags cannot be reversed with -XNo<blah>
-- They are used to place hard requirements on what GHC Haskell language
-- features can be used.
safeHaskellFlagsDeps :: [(Deprecation, FlagSpec SafeHaskellMode)]
safeHaskellFlagsDeps :: [(Deprecation, FlagSpec SafeHaskellMode)]
safeHaskellFlagsDeps = [forall {flag}. Show flag => flag -> (Deprecation, FlagSpec flag)
mkF SafeHaskellMode
Sf_Unsafe, forall {flag}. Show flag => flag -> (Deprecation, FlagSpec flag)
mkF SafeHaskellMode
Sf_Trustworthy, forall {flag}. Show flag => flag -> (Deprecation, FlagSpec flag)
mkF SafeHaskellMode
Sf_Safe]
    where mkF :: flag -> (Deprecation, FlagSpec flag)
mkF flag
flag = forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec (forall a. Show a => a -> [Char]
show flag
flag) flag
flag

-- | These -X<blah> flags can all be reversed with -XNo<blah>
xFlags :: [FlagSpec LangExt.Extension]
xFlags :: [FlagSpec Extension]
xFlags = forall a b. (a -> b) -> [a] -> [b]
map forall a b. (a, b) -> b
snd [(Deprecation, FlagSpec Extension)]
xFlagsDeps

xFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]
xFlagsDeps :: [(Deprecation, FlagSpec Extension)]
xFlagsDeps = [
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
-- See Note [Adding a language extension]
-- Please keep the list of flags below sorted alphabetically
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"AllowAmbiguousTypes"              Extension
LangExt.AllowAmbiguousTypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"AlternativeLayoutRule"            Extension
LangExt.AlternativeLayoutRule,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"AlternativeLayoutRuleTransitional"
                                              Extension
LangExt.AlternativeLayoutRuleTransitional,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"Arrows"                           Extension
LangExt.Arrows,
  forall flag.
[Char]
-> flag -> (Bool -> Bool) -> [Char] -> (Deprecation, FlagSpec flag)
depFlagSpecCond [Char]
"AutoDeriveTypeable"        Extension
LangExt.AutoDeriveTypeable
    forall a. a -> a
id
         ([Char]
"Typeable instances are created automatically " forall a. [a] -> [a] -> [a]
++
                     [Char]
"for all types since GHC 8.2."),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"BangPatterns"                     Extension
LangExt.BangPatterns,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"BinaryLiterals"                   Extension
LangExt.BinaryLiterals,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"CApiFFI"                          Extension
LangExt.CApiFFI,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"CPP"                              Extension
LangExt.Cpp,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"CUSKs"                            Extension
LangExt.CUSKs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ConstrainedClassMethods"          Extension
LangExt.ConstrainedClassMethods,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ConstraintKinds"                  Extension
LangExt.ConstraintKinds,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DataKinds"                        Extension
LangExt.DataKinds,
  forall flag.
[Char]
-> flag -> (Bool -> Bool) -> [Char] -> (Deprecation, FlagSpec flag)
depFlagSpecCond [Char]
"DatatypeContexts"          Extension
LangExt.DatatypeContexts
    forall a. a -> a
id
         ([Char]
"It was widely considered a misfeature, " forall a. [a] -> [a] -> [a]
++
                     [Char]
"and has been removed from the Haskell language."),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DefaultSignatures"                Extension
LangExt.DefaultSignatures,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveAnyClass"                   Extension
LangExt.DeriveAnyClass,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveDataTypeable"               Extension
LangExt.DeriveDataTypeable,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveFoldable"                   Extension
LangExt.DeriveFoldable,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveFunctor"                    Extension
LangExt.DeriveFunctor,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveGeneric"                    Extension
LangExt.DeriveGeneric,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveLift"                       Extension
LangExt.DeriveLift,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeriveTraversable"                Extension
LangExt.DeriveTraversable,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DerivingStrategies"               Extension
LangExt.DerivingStrategies,
  forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
"DerivingVia"                     Extension
LangExt.DerivingVia
                                              Bool -> DynP ()
setDeriveVia,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DisambiguateRecordFields"         Extension
LangExt.DisambiguateRecordFields,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DoAndIfThenElse"                  Extension
LangExt.DoAndIfThenElse,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"BlockArguments"                   Extension
LangExt.BlockArguments,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"DoRec"                        Extension
LangExt.RecursiveDo
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"RecursiveDo"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DuplicateRecordFields"            Extension
LangExt.DuplicateRecordFields,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"FieldSelectors"                   Extension
LangExt.FieldSelectors,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"EmptyCase"                        Extension
LangExt.EmptyCase,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"EmptyDataDecls"                   Extension
LangExt.EmptyDataDecls,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"EmptyDataDeriving"                Extension
LangExt.EmptyDataDeriving,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ExistentialQuantification"        Extension
LangExt.ExistentialQuantification,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ExplicitForAll"                   Extension
LangExt.ExplicitForAll,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ExplicitNamespaces"               Extension
LangExt.ExplicitNamespaces,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ExtendedDefaultRules"             Extension
LangExt.ExtendedDefaultRules,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"FlexibleContexts"                 Extension
LangExt.FlexibleContexts,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"FlexibleInstances"                Extension
LangExt.FlexibleInstances,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ForeignFunctionInterface"         Extension
LangExt.ForeignFunctionInterface,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"FunctionalDependencies"           Extension
LangExt.FunctionalDependencies,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"GADTSyntax"                       Extension
LangExt.GADTSyntax,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"GADTs"                            Extension
LangExt.GADTs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"GHCForeignImportPrim"             Extension
LangExt.GHCForeignImportPrim,
  forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
"GeneralizedNewtypeDeriving"      Extension
LangExt.GeneralizedNewtypeDeriving
                                              Bool -> DynP ()
setGenDeriving,
  forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
"GeneralisedNewtypeDeriving"      Extension
LangExt.GeneralizedNewtypeDeriving
                                              Bool -> DynP ()
setGenDeriving,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ImplicitParams"                   Extension
LangExt.ImplicitParams,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ImplicitPrelude"                  Extension
LangExt.ImplicitPrelude,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ImportQualifiedPost"              Extension
LangExt.ImportQualifiedPost,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ImpredicativeTypes"               Extension
LangExt.ImpredicativeTypes,
  forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
"IncoherentInstances"             Extension
LangExt.IncoherentInstances
                                              Bool -> DynP ()
setIncoherentInsts,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TypeFamilyDependencies"           Extension
LangExt.TypeFamilyDependencies,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"InstanceSigs"                     Extension
LangExt.InstanceSigs,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ApplicativeDo"                    Extension
LangExt.ApplicativeDo,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"InterruptibleFFI"                 Extension
LangExt.InterruptibleFFI,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"JavaScriptFFI"                    Extension
LangExt.JavaScriptFFI,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"KindSignatures"                   Extension
LangExt.KindSignatures,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"LambdaCase"                       Extension
LangExt.LambdaCase,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"LexicalNegation"                  Extension
LangExt.LexicalNegation,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"LiberalTypeSynonyms"              Extension
LangExt.LiberalTypeSynonyms,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"LinearTypes"                      Extension
LangExt.LinearTypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"MagicHash"                        Extension
LangExt.MagicHash,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"MonadComprehensions"              Extension
LangExt.MonadComprehensions,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"MonoLocalBinds"                   Extension
LangExt.MonoLocalBinds,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"DeepSubsumption"                  Extension
LangExt.DeepSubsumption,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"MonomorphismRestriction"          Extension
LangExt.MonomorphismRestriction,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"MultiParamTypeClasses"            Extension
LangExt.MultiParamTypeClasses,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"MultiWayIf"                       Extension
LangExt.MultiWayIf,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NumericUnderscores"               Extension
LangExt.NumericUnderscores,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NPlusKPatterns"                   Extension
LangExt.NPlusKPatterns,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NamedFieldPuns"                   Extension
LangExt.NamedFieldPuns,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NamedWildCards"                   Extension
LangExt.NamedWildCards,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NegativeLiterals"                 Extension
LangExt.NegativeLiterals,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"HexFloatLiterals"                 Extension
LangExt.HexFloatLiterals,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NondecreasingIndentation"         Extension
LangExt.NondecreasingIndentation,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"NullaryTypeClasses"           Extension
LangExt.NullaryTypeClasses
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"MultiParamTypeClasses"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"NumDecimals"                      Extension
LangExt.NumDecimals,
  forall flag.
[Char]
-> flag
-> (Bool -> DynP ())
-> [Char]
-> (Deprecation, FlagSpec flag)
depFlagSpecOp [Char]
"OverlappingInstances"        Extension
LangExt.OverlappingInstances
    Bool -> DynP ()
setOverlappingInsts
    [Char]
"instead use per-instance pragmas OVERLAPPING/OVERLAPPABLE/OVERLAPS",
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"OverloadedLabels"                 Extension
LangExt.OverloadedLabels,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"OverloadedLists"                  Extension
LangExt.OverloadedLists,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"OverloadedStrings"                Extension
LangExt.OverloadedStrings,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PackageImports"                   Extension
LangExt.PackageImports,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ParallelArrays"                   Extension
LangExt.ParallelArrays,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ParallelListComp"                 Extension
LangExt.ParallelListComp,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PartialTypeSignatures"            Extension
LangExt.PartialTypeSignatures,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PatternGuards"                    Extension
LangExt.PatternGuards,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"PatternSignatures"            Extension
LangExt.ScopedTypeVariables
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"ScopedTypeVariables"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PatternSynonyms"                  Extension
LangExt.PatternSynonyms,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PolyKinds"                        Extension
LangExt.PolyKinds,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PolymorphicComponents"            Extension
LangExt.RankNTypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"QuantifiedConstraints"            Extension
LangExt.QuantifiedConstraints,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"PostfixOperators"                 Extension
LangExt.PostfixOperators,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"QuasiQuotes"                      Extension
LangExt.QuasiQuotes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"QualifiedDo"                      Extension
LangExt.QualifiedDo,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"Rank2Types"                       Extension
LangExt.RankNTypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"RankNTypes"                       Extension
LangExt.RankNTypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"RebindableSyntax"                 Extension
LangExt.RebindableSyntax,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"OverloadedRecordDot"              Extension
LangExt.OverloadedRecordDot,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"OverloadedRecordUpdate"           Extension
LangExt.OverloadedRecordUpdate,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"RecordPuns"                   Extension
LangExt.NamedFieldPuns
    ([Char] -> Bool -> [Char]
deprecatedForExtension [Char]
"NamedFieldPuns"),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"RecordWildCards"                  Extension
LangExt.RecordWildCards,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"RecursiveDo"                      Extension
LangExt.RecursiveDo,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"RelaxedLayout"                    Extension
LangExt.RelaxedLayout,
  forall flag.
[Char]
-> flag -> (Bool -> Bool) -> [Char] -> (Deprecation, FlagSpec flag)
depFlagSpecCond [Char]
"RelaxedPolyRec"            Extension
LangExt.RelaxedPolyRec
    Bool -> Bool
not
         [Char]
"You can't turn off RelaxedPolyRec any more",
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"RoleAnnotations"                  Extension
LangExt.RoleAnnotations,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ScopedTypeVariables"              Extension
LangExt.ScopedTypeVariables,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"StandaloneDeriving"               Extension
LangExt.StandaloneDeriving,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"StarIsType"                       Extension
LangExt.StarIsType,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"StaticPointers"                   Extension
LangExt.StaticPointers,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"Strict"                           Extension
LangExt.Strict,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"StrictData"                       Extension
LangExt.StrictData,
  forall flag.
[Char] -> flag -> (Bool -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
"TemplateHaskell"                 Extension
LangExt.TemplateHaskell
                                              Bool -> DynP ()
checkTemplateHaskellOk,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TemplateHaskellQuotes"            Extension
LangExt.TemplateHaskellQuotes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"StandaloneKindSignatures"         Extension
LangExt.StandaloneKindSignatures,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TraditionalRecordSyntax"          Extension
LangExt.TraditionalRecordSyntax,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TransformListComp"                Extension
LangExt.TransformListComp,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TupleSections"                    Extension
LangExt.TupleSections,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TypeApplications"                 Extension
LangExt.TypeApplications,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TypeData"                         Extension
LangExt.TypeData,
  forall flag.
[Char] -> flag -> (Bool -> [Char]) -> (Deprecation, FlagSpec flag)
depFlagSpec' [Char]
"TypeInType"                   Extension
LangExt.TypeInType
    ([[Char]] -> Bool -> [Char]
deprecatedForExtensions [[Char]
"DataKinds", [Char]
"PolyKinds"]),
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TypeFamilies"                     Extension
LangExt.TypeFamilies,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TypeOperators"                    Extension
LangExt.TypeOperators,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"TypeSynonymInstances"             Extension
LangExt.TypeSynonymInstances,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UnboxedTuples"                    Extension
LangExt.UnboxedTuples,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UnboxedSums"                      Extension
LangExt.UnboxedSums,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UndecidableInstances"             Extension
LangExt.UndecidableInstances,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UndecidableSuperClasses"          Extension
LangExt.UndecidableSuperClasses,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UnicodeSyntax"                    Extension
LangExt.UnicodeSyntax,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UnliftedDatatypes"                Extension
LangExt.UnliftedDatatypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UnliftedFFITypes"                 Extension
LangExt.UnliftedFFITypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"UnliftedNewtypes"                 Extension
LangExt.UnliftedNewtypes,
  forall flag. [Char] -> flag -> (Deprecation, FlagSpec flag)
flagSpec [Char]
"ViewPatterns"                     Extension
LangExt.ViewPatterns
  ]

defaultFlags :: Settings -> [GeneralFlag]
defaultFlags :: Settings -> [GeneralFlag]
defaultFlags Settings
settings
-- See Note [Updating flag description in the User's Guide]
  = [ GeneralFlag
Opt_AutoLinkPackages,
      GeneralFlag
Opt_DiagnosticsShowCaret,
      GeneralFlag
Opt_EmbedManifest,
      GeneralFlag
Opt_FamAppCache,
      GeneralFlag
Opt_GenManifest,
      GeneralFlag
Opt_GhciHistory,
      GeneralFlag
Opt_GhciSandbox,
      GeneralFlag
Opt_HelpfulErrors,
      GeneralFlag
Opt_KeepHiFiles,
      GeneralFlag
Opt_KeepOFiles,
      GeneralFlag
Opt_OmitYields,
      GeneralFlag
Opt_PrintBindContents,
      GeneralFlag
Opt_ProfCountEntries,
      GeneralFlag
Opt_SharedImplib,
      GeneralFlag
Opt_SimplPreInlining,
      GeneralFlag
Opt_VersionMacros,
      GeneralFlag
Opt_RPath,
      GeneralFlag
Opt_DumpWithWays,
      GeneralFlag
Opt_CompactUnwind,
      GeneralFlag
Opt_ShowErrorContext,
      GeneralFlag
Opt_SuppressStgReps
    ]

    forall a. [a] -> [a] -> [a]
++ [GeneralFlag
f | ([Int]
ns,GeneralFlag
f) <- [([Int], GeneralFlag)]
optLevelFlags, Int
0 forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Int]
ns]
             -- The default -O0 options

    -- Default floating flags (see Note [RHS Floating])
    forall a. [a] -> [a] -> [a]
++ [ GeneralFlag
Opt_LocalFloatOut, GeneralFlag
Opt_LocalFloatOutTopLevel ]


    forall a. [a] -> [a] -> [a]
++ Platform -> [GeneralFlag]
default_PIC Platform
platform

    forall a. [a] -> [a] -> [a]
++ [GeneralFlag]
validHoleFitDefaults


    where platform :: Platform
platform = Settings -> Platform
sTargetPlatform Settings
settings

-- | These are the default settings for the display and sorting of valid hole
--  fits in typed-hole error messages. See Note [Valid hole fits include ...]
 -- in the "GHC.Tc.Errors.Hole" module.
validHoleFitDefaults :: [GeneralFlag]
validHoleFitDefaults :: [GeneralFlag]
validHoleFitDefaults
  =  [ GeneralFlag
Opt_ShowTypeAppOfHoleFits
     , GeneralFlag
Opt_ShowTypeOfHoleFits
     , GeneralFlag
Opt_ShowProvOfHoleFits
     , GeneralFlag
Opt_ShowMatchesOfHoleFits
     , GeneralFlag
Opt_ShowValidHoleFits
     , GeneralFlag
Opt_SortValidHoleFits
     , GeneralFlag
Opt_SortBySizeHoleFits
     , GeneralFlag
Opt_ShowHoleConstraints ]


validHoleFitsImpliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
validHoleFitsImpliedGFlags :: [(GeneralFlag, Bool, GeneralFlag)]
validHoleFitsImpliedGFlags
  = [ (GeneralFlag
Opt_UnclutterValidHoleFits, Bool
turnOff, GeneralFlag
Opt_ShowTypeAppOfHoleFits)
    , (GeneralFlag
Opt_UnclutterValidHoleFits, Bool
turnOff, GeneralFlag
Opt_ShowTypeAppVarsOfHoleFits)
    , (GeneralFlag
Opt_UnclutterValidHoleFits, Bool
turnOff, GeneralFlag
Opt_ShowDocsOfHoleFits)
    , (GeneralFlag
Opt_ShowTypeAppVarsOfHoleFits, Bool
turnOff, GeneralFlag
Opt_ShowTypeAppOfHoleFits)
    , (GeneralFlag
Opt_UnclutterValidHoleFits, Bool
turnOff, GeneralFlag
Opt_ShowProvOfHoleFits) ]

default_PIC :: Platform -> [GeneralFlag]
default_PIC :: Platform -> [GeneralFlag]
default_PIC Platform
platform =
  case (Platform -> OS
platformOS Platform
platform, Platform -> Arch
platformArch Platform
platform) of
    -- Darwin always requires PIC.  Especially on more recent macOS releases
    -- there will be a 4GB __ZEROPAGE that prevents us from using 32bit addresses
    -- while we could work around this on x86_64 (like WINE does), we won't be
    -- able on aarch64, where this is enforced.
    (OS
OSDarwin,  Arch
ArchX86_64)  -> [GeneralFlag
Opt_PIC]
    -- For AArch64, we need to always have PIC enabled.  The relocation model
    -- on AArch64 does not permit arbitrary relocations.  Under ASLR, we can't
    -- control much how far apart symbols are in memory for our in-memory static
    -- linker;  and thus need to ensure we get sufficiently capable relocations.
    -- This requires PIC on AArch64, and ExternalDynamicRefs on Linux as on top
    -- of that.  Subsequently we expect all code on aarch64/linux (and macOS) to
    -- be built with -fPIC.
    (OS
OSDarwin,  Arch
ArchAArch64) -> [GeneralFlag
Opt_PIC]
    (OS
OSLinux,   Arch
ArchAArch64) -> [GeneralFlag
Opt_PIC, GeneralFlag
Opt_ExternalDynamicRefs]
    (OS
OSLinux,   ArchARM {})  -> [GeneralFlag
Opt_PIC, GeneralFlag
Opt_ExternalDynamicRefs]
    (OS
OSOpenBSD, Arch
ArchX86_64)  -> [GeneralFlag
Opt_PIC] -- Due to PIE support in
                                         -- OpenBSD since 5.3 release
                                         -- (1 May 2013) we need to
                                         -- always generate PIC. See
                                         -- #10597 for more
                                         -- information.
    (OS, Arch)
_                      -> []

-- General flags that are switched on/off when other general flags are switched
-- on
impliedGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
impliedGFlags :: [(GeneralFlag, Bool, GeneralFlag)]
impliedGFlags = [(GeneralFlag
Opt_DeferTypeErrors, Bool
turnOn, GeneralFlag
Opt_DeferTypedHoles)
                ,(GeneralFlag
Opt_DeferTypeErrors, Bool
turnOn, GeneralFlag
Opt_DeferOutOfScopeVariables)
                ,(GeneralFlag
Opt_DoLinearCoreLinting, Bool
turnOn, GeneralFlag
Opt_DoCoreLinting)
                ,(GeneralFlag
Opt_Strictness, Bool
turnOn, GeneralFlag
Opt_WorkerWrapper)
                ,(GeneralFlag
Opt_WriteIfSimplifiedCore, Bool
turnOn, GeneralFlag
Opt_WriteInterface)
                ,(GeneralFlag
Opt_ByteCodeAndObjectCode, Bool
turnOn, GeneralFlag
Opt_WriteIfSimplifiedCore)
                ] forall a. [a] -> [a] -> [a]
++ [(GeneralFlag, Bool, GeneralFlag)]
validHoleFitsImpliedGFlags

-- General flags that are switched on/off when other general flags are switched
-- off
impliedOffGFlags :: [(GeneralFlag, TurnOnFlag, GeneralFlag)]
impliedOffGFlags :: [(GeneralFlag, Bool, GeneralFlag)]
impliedOffGFlags = [(GeneralFlag
Opt_Strictness, Bool
turnOff, GeneralFlag
Opt_WorkerWrapper)]

impliedXFlags :: [(LangExt.Extension, TurnOnFlag, LangExt.Extension)]
impliedXFlags :: [(Extension, Bool, Extension)]
impliedXFlags
-- See Note [Updating flag description in the User's Guide]
  = [ (Extension
LangExt.RankNTypes,                Bool
turnOn, Extension
LangExt.ExplicitForAll)
    , (Extension
LangExt.QuantifiedConstraints,     Bool
turnOn, Extension
LangExt.ExplicitForAll)
    , (Extension
LangExt.ScopedTypeVariables,       Bool
turnOn, Extension
LangExt.ExplicitForAll)
    , (Extension
LangExt.LiberalTypeSynonyms,       Bool
turnOn, Extension
LangExt.ExplicitForAll)
    , (Extension
LangExt.ExistentialQuantification, Bool
turnOn, Extension
LangExt.ExplicitForAll)
    , (Extension
LangExt.FlexibleInstances,         Bool
turnOn, Extension
LangExt.TypeSynonymInstances)
    , (Extension
LangExt.FunctionalDependencies,    Bool
turnOn, Extension
LangExt.MultiParamTypeClasses)
    , (Extension
LangExt.MultiParamTypeClasses,     Bool
turnOn, Extension
LangExt.ConstrainedClassMethods)  -- c.f. #7854
    , (Extension
LangExt.TypeFamilyDependencies,    Bool
turnOn, Extension
LangExt.TypeFamilies)

    , (Extension
LangExt.RebindableSyntax, Bool
turnOff, Extension
LangExt.ImplicitPrelude)      -- NB: turn off!

    , (Extension
LangExt.DerivingVia, Bool
turnOn, Extension
LangExt.DerivingStrategies)

    , (Extension
LangExt.GADTs,            Bool
turnOn, Extension
LangExt.GADTSyntax)
    , (Extension
LangExt.GADTs,            Bool
turnOn, Extension
LangExt.MonoLocalBinds)
    , (Extension
LangExt.TypeFamilies,     Bool
turnOn, Extension
LangExt.MonoLocalBinds)

    , (Extension
LangExt.TypeFamilies,     Bool
turnOn, Extension
LangExt.KindSignatures)  -- Type families use kind signatures
    , (Extension
LangExt.PolyKinds,        Bool
turnOn, Extension
LangExt.KindSignatures)  -- Ditto polymorphic kinds

    -- TypeInType is now just a synonym for a couple of other extensions.
    , (Extension
LangExt.TypeInType,       Bool
turnOn, Extension
LangExt.DataKinds)
    , (Extension
LangExt.TypeInType,       Bool
turnOn, Extension
LangExt.PolyKinds)
    , (Extension
LangExt.TypeInType,       Bool
turnOn, Extension
LangExt.KindSignatures)

    -- Standalone kind signatures are a replacement for CUSKs.
    , (Extension
LangExt.StandaloneKindSignatures, Bool
turnOff, Extension
LangExt.CUSKs)

    -- AutoDeriveTypeable is not very useful without DeriveDataTypeable
    , (Extension
LangExt.AutoDeriveTypeable, Bool
turnOn, Extension
LangExt.DeriveDataTypeable)

    -- We turn this on so that we can export associated type
    -- type synonyms in subordinates (e.g. MyClass(type AssocType))
    , (Extension
LangExt.TypeFamilies,     Bool
turnOn, Extension
LangExt.ExplicitNamespaces)
    , (Extension
LangExt.TypeOperators, Bool
turnOn, Extension
LangExt.ExplicitNamespaces)

    , (Extension
LangExt.ImpredicativeTypes,  Bool
turnOn, Extension
LangExt.RankNTypes)

        -- Record wild-cards implies field disambiguation
        -- Otherwise if you write (C {..}) you may well get
        -- stuff like " 'a' not in scope ", which is a bit silly
        -- if the compiler has just filled in field 'a' of constructor 'C'
    , (Extension
LangExt.RecordWildCards,     Bool
turnOn, Extension
LangExt.DisambiguateRecordFields)

    , (Extension
LangExt.ParallelArrays, Bool
turnOn, Extension
LangExt.ParallelListComp)

    , (Extension
LangExt.JavaScriptFFI, Bool
turnOn, Extension
LangExt.InterruptibleFFI)

    , (Extension
LangExt.DeriveTraversable, Bool
turnOn, Extension
LangExt.DeriveFunctor)
    , (Extension
LangExt.DeriveTraversable, Bool
turnOn, Extension
LangExt.DeriveFoldable)

    -- Duplicate record fields require field disambiguation
    , (Extension
LangExt.DuplicateRecordFields, Bool
turnOn, Extension
LangExt.DisambiguateRecordFields)

    , (Extension
LangExt.TemplateHaskell, Bool
turnOn, Extension
LangExt.TemplateHaskellQuotes)
    , (Extension
LangExt.Strict, Bool
turnOn, Extension
LangExt.StrictData)

    -- Historically only UnboxedTuples was required for unboxed sums to work.
    -- To avoid breaking code, we make UnboxedTuples imply UnboxedSums.
    , (Extension
LangExt.UnboxedTuples, Bool
turnOn, Extension
LangExt.UnboxedSums)

    -- The extensions needed to declare an H98 unlifted data type
    , (Extension
LangExt.UnliftedDatatypes, Bool
turnOn, Extension
LangExt.DataKinds)
    , (Extension
LangExt.UnliftedDatatypes, Bool
turnOn, Extension
LangExt.StandaloneKindSignatures)
  ]

-- Note [When is StarIsType enabled]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- The StarIsType extension determines whether to treat '*' as a regular type
-- operator or as a synonym for 'Data.Kind.Type'. Many existing pre-TypeInType
-- programs expect '*' to be synonymous with 'Type', so by default StarIsType is
-- enabled.
--
-- Programs that use TypeOperators might expect to repurpose '*' for
-- multiplication or another binary operation, but making TypeOperators imply
-- NoStarIsType caused too much breakage on Hackage.
--

-- Note [Documenting optimisation flags]
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
--
-- If you change the list of flags enabled for particular optimisation levels
-- please remember to update the User's Guide. The relevant file is:
--
--   docs/users_guide/using-optimisation.rst
--
-- Make sure to note whether a flag is implied by -O0, -O or -O2.

optLevelFlags :: [([Int], GeneralFlag)]
-- Default settings of flags, before any command-line overrides
optLevelFlags :: [([Int], GeneralFlag)]
optLevelFlags -- see Note [Documenting optimisation flags]
  = [ ([Int
0,Int
1,Int
2], GeneralFlag
Opt_DoLambdaEtaExpansion)
    , ([Int
0,Int
1,Int
2], GeneralFlag
Opt_DoEtaReduction)       -- See Note [Eta-reduction in -O0]
    , ([Int
0,Int
1,Int
2], GeneralFlag
Opt_LlvmTBAA)
    , ([Int
0,Int
1,Int
2], GeneralFlag
Opt_ProfManualCcs )
    , ([Int
2], GeneralFlag
Opt_DictsStrict)

    , ([Int
0],     GeneralFlag
Opt_IgnoreInterfacePragmas)
    , ([Int
0],     GeneralFlag
Opt_OmitInterfacePragmas)

    , ([Int
1,Int
2],   GeneralFlag
Opt_CoreConstantFolding)

    , ([Int
1,Int
2],   GeneralFlag
Opt_CallArity)
    , ([Int
1,Int
2],   GeneralFlag
Opt_Exitification)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CaseMerge)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CaseFolding)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CmmElimCommonBlocks)
    , ([Int
2],     GeneralFlag
Opt_AsmShortcutting)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CmmSink)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CmmStaticPred)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CSE)
    , ([Int
1,Int
2],   GeneralFlag
Opt_StgCSE)
    , ([Int
2],     GeneralFlag
Opt_StgLiftLams)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CmmControlFlow)

    , ([Int
1,Int
2],   GeneralFlag
Opt_EnableRewriteRules)
          -- Off for -O0.   Otherwise we desugar list literals
          -- to 'build' but don't run the simplifier passes that
          -- would rewrite them back to cons cells!  This seems
          -- silly, and matters for the GHCi debugger.

    , ([Int
1,Int
2],   GeneralFlag
Opt_FloatIn)
    , ([Int
1,Int
2],   GeneralFlag
Opt_FullLaziness)
    , ([Int
1,Int
2],   GeneralFlag
Opt_IgnoreAsserts)
    , ([Int
1,Int
2],   GeneralFlag
Opt_Loopification)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CfgBlocklayout)      -- Experimental

    , ([Int
1,Int
2],   GeneralFlag
Opt_Specialise)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CrossModuleSpecialise)
    , ([Int
1,Int
2],   GeneralFlag
Opt_InlineGenerics)
    , ([Int
1,Int
2],   GeneralFlag
Opt_Strictness)
    , ([Int
1,Int
2],   GeneralFlag
Opt_UnboxSmallStrictFields)
    , ([Int
1,Int
2],   GeneralFlag
Opt_CprAnal)
    , ([Int
1,Int
2],   GeneralFlag
Opt_WorkerWrapper)
    , ([Int
1,Int
2],   GeneralFlag
Opt_SolveConstantDicts)
    , ([Int
1,Int
2],   GeneralFlag
Opt_NumConstantFolding)

    , ([Int
2],     GeneralFlag
Opt_LiberateCase)
    , ([Int
2],     GeneralFlag
Opt_SpecConstr)
    , ([Int
2],     GeneralFlag
Opt_FastPAPCalls)
--  , ([2],     Opt_RegsGraph)
--   RegsGraph suffers performance regression. See #7679
--  , ([2],     Opt_StaticArgumentTransformation)
--   Static Argument Transformation needs investigation. See #9374
    ]


enableUnusedBinds :: DynP ()
enableUnusedBinds :: DynP ()
enableUnusedBinds = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setWarningFlag [WarningFlag]
unusedBindsFlags

disableUnusedBinds :: DynP ()
disableUnusedBinds :: DynP ()
disableUnusedBinds = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetWarningFlag [WarningFlag]
unusedBindsFlags

-- | Things you get with `-dlint`.
enableDLint :: DynP ()
enableDLint :: DynP ()
enableDLint = do
    forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ GeneralFlag -> DynP ()
setGeneralFlag [GeneralFlag]
dLintFlags
    Way -> DynP ()
addWayDynP Way
WayDebug
  where
    dLintFlags :: [GeneralFlag]
    dLintFlags :: [GeneralFlag]
dLintFlags =
        [ GeneralFlag
Opt_DoCoreLinting
        , GeneralFlag
Opt_DoStgLinting
        , GeneralFlag
Opt_DoCmmLinting
        , GeneralFlag
Opt_DoAsmLinting
        , GeneralFlag
Opt_CatchNonexhaustiveCases
        , GeneralFlag
Opt_LlvmFillUndefWithGarbage
        ]

enableGlasgowExts :: DynP ()
enableGlasgowExts :: DynP ()
enableGlasgowExts = do GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PrintExplicitForalls
                       forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Extension -> DynP ()
setExtensionFlag [Extension]
glasgowExtsFlags

disableGlasgowExts :: DynP ()
disableGlasgowExts :: DynP ()
disableGlasgowExts = do GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_PrintExplicitForalls
                        forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ Extension -> DynP ()
unSetExtensionFlag [Extension]
glasgowExtsFlags

-- Please keep what_glasgow_exts_does.rst up to date with this list
glasgowExtsFlags :: [LangExt.Extension]
glasgowExtsFlags :: [Extension]
glasgowExtsFlags = [
             Extension
LangExt.ConstrainedClassMethods
           , Extension
LangExt.DeriveDataTypeable
           , Extension
LangExt.DeriveFoldable
           , Extension
LangExt.DeriveFunctor
           , Extension
LangExt.DeriveGeneric
           , Extension
LangExt.DeriveTraversable
           , Extension
LangExt.EmptyDataDecls
           , Extension
LangExt.ExistentialQuantification
           , Extension
LangExt.ExplicitNamespaces
           , Extension
LangExt.FlexibleContexts
           , Extension
LangExt.FlexibleInstances
           , Extension
LangExt.ForeignFunctionInterface
           , Extension
LangExt.FunctionalDependencies
           , Extension
LangExt.GeneralizedNewtypeDeriving
           , Extension
LangExt.ImplicitParams
           , Extension
LangExt.KindSignatures
           , Extension
LangExt.LiberalTypeSynonyms
           , Extension
LangExt.MagicHash
           , Extension
LangExt.MultiParamTypeClasses
           , Extension
LangExt.ParallelListComp
           , Extension
LangExt.PatternGuards
           , Extension
LangExt.PostfixOperators
           , Extension
LangExt.RankNTypes
           , Extension
LangExt.RecursiveDo
           , Extension
LangExt.ScopedTypeVariables
           , Extension
LangExt.StandaloneDeriving
           , Extension
LangExt.TypeOperators
           , Extension
LangExt.TypeSynonymInstances
           , Extension
LangExt.UnboxedTuples
           , Extension
LangExt.UnicodeSyntax
           , Extension
LangExt.UnliftedFFITypes ]

setWarnSafe :: Bool -> DynP ()
setWarnSafe :: Bool -> DynP ()
setWarnSafe Bool
True  = forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SrcSpan
l -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { warnSafeOnLoc :: SrcSpan
warnSafeOnLoc = SrcSpan
l })
setWarnSafe Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()

setWarnUnsafe :: Bool -> DynP ()
setWarnUnsafe :: Bool -> DynP ()
setWarnUnsafe Bool
True  = forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SrcSpan
l -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { warnUnsafeOnLoc :: SrcSpan
warnUnsafeOnLoc = SrcSpan
l })
setWarnUnsafe Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()

setPackageTrust :: DynP ()
setPackageTrust :: DynP ()
setPackageTrust = do
    GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_PackageTrust
    SrcSpan
l <- forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
    (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { pkgTrustOnLoc :: SrcSpan
pkgTrustOnLoc = SrcSpan
l }

setGenDeriving :: TurnOnFlag -> DynP ()
setGenDeriving :: Bool -> DynP ()
setGenDeriving Bool
True  = forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SrcSpan
l -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { newDerivOnLoc :: SrcSpan
newDerivOnLoc = SrcSpan
l })
setGenDeriving Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()

setDeriveVia :: TurnOnFlag -> DynP ()
setDeriveVia :: Bool -> DynP ()
setDeriveVia Bool
True  = forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SrcSpan
l -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { deriveViaOnLoc :: SrcSpan
deriveViaOnLoc = SrcSpan
l })
setDeriveVia Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()

setOverlappingInsts :: TurnOnFlag -> DynP ()
setOverlappingInsts :: Bool -> DynP ()
setOverlappingInsts Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()
setOverlappingInsts Bool
True = do
  SrcSpan
l <- forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { overlapInstLoc :: SrcSpan
overlapInstLoc = SrcSpan
l })

setIncoherentInsts :: TurnOnFlag -> DynP ()
setIncoherentInsts :: Bool -> DynP ()
setIncoherentInsts Bool
False = forall (m :: * -> *) a. Monad m => a -> m a
return ()
setIncoherentInsts Bool
True = do
  SrcSpan
l <- forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { incoherentOnLoc :: SrcSpan
incoherentOnLoc = SrcSpan
l })

checkTemplateHaskellOk :: TurnOnFlag -> DynP ()
checkTemplateHaskellOk :: Bool -> DynP ()
checkTemplateHaskellOk Bool
_turn_on
  = forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \SrcSpan
l -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { thOnLoc :: SrcSpan
thOnLoc = SrcSpan
l })

{- **********************************************************************
%*                                                                      *
                DynFlags constructors
%*                                                                      *
%********************************************************************* -}

type DynP = EwM (CmdLineP DynFlags)

upd :: (DynFlags -> DynFlags) -> DynP ()
upd :: (DynFlags -> DynFlags) -> DynP ()
upd DynFlags -> DynFlags
f = forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM (do DynFlags
dflags <- forall s. CmdLineP s s
getCmdLineState
                    forall s. s -> CmdLineP s ()
putCmdLineState forall a b. (a -> b) -> a -> b
$! DynFlags -> DynFlags
f DynFlags
dflags)

updM :: (DynFlags -> DynP DynFlags) -> DynP ()
updM :: (DynFlags -> DynP DynFlags) -> DynP ()
updM DynFlags -> DynP DynFlags
f = do DynFlags
dflags <- forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM forall s. CmdLineP s s
getCmdLineState
            DynFlags
dflags' <- DynFlags -> DynP DynFlags
f DynFlags
dflags
            forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM forall a b. (a -> b) -> a -> b
$ forall s. s -> CmdLineP s ()
putCmdLineState forall a b. (a -> b) -> a -> b
$! DynFlags
dflags'

--------------- Constructor functions for OptKind -----------------
noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg :: (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg DynFlags -> DynFlags
fn = forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd DynFlags -> DynFlags
fn)

noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM :: (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM DynFlags -> DynP DynFlags
fn = forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynP DynFlags) -> DynP ()
updM DynFlags -> DynP DynFlags
fn)

hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg :: ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
fn = forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg ((DynFlags -> DynFlags) -> DynP ()
upd forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
fn)

sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg :: ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg [Char] -> DynFlags -> DynFlags
fn = forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg ((DynFlags -> DynFlags) -> DynP ()
upd forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
fn)

intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix :: (Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix Int -> DynFlags -> DynFlags
fn = forall (m :: * -> *). (Int -> EwM m ()) -> OptKind m
IntSuffix (\Int
n -> (DynFlags -> DynFlags) -> DynP ()
upd (Int -> DynFlags -> DynFlags
fn Int
n))

intSuffixM :: (Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM :: (Int -> DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffixM Int -> DynFlags -> DynP DynFlags
fn = forall (m :: * -> *). (Int -> EwM m ()) -> OptKind m
IntSuffix (\Int
n -> (DynFlags -> DynP DynFlags) -> DynP ()
updM (Int -> DynFlags -> DynP DynFlags
fn Int
n))

wordSuffix :: (Word -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
wordSuffix :: (Word -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
wordSuffix Word -> DynFlags -> DynFlags
fn = forall (m :: * -> *). (Word -> EwM m ()) -> OptKind m
WordSuffix (\Word
n -> (DynFlags -> DynFlags) -> DynP ()
upd (Word -> DynFlags -> DynFlags
fn Word
n))

floatSuffix :: (Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
floatSuffix :: (Float -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
floatSuffix Float -> DynFlags -> DynFlags
fn = forall (m :: * -> *). (Float -> EwM m ()) -> OptKind m
FloatSuffix (\Float
n -> (DynFlags -> DynFlags) -> DynP ()
upd (Float -> DynFlags -> DynFlags
fn Float
n))

optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
              -> OptKind (CmdLineP DynFlags)
optIntSuffixM :: (Maybe Int -> DynFlags -> DynP DynFlags)
-> OptKind (CmdLineP DynFlags)
optIntSuffixM Maybe Int -> DynFlags -> DynP DynFlags
fn = forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix (\Maybe Int
mi -> (DynFlags -> DynP DynFlags) -> DynP ()
updM (Maybe Int -> DynFlags -> DynP DynFlags
fn Maybe Int
mi))

setDumpFlag :: DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag :: DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
dump_flag = forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DumpFlag -> DynP ()
setDumpFlag' DumpFlag
dump_flag)

--------------------------
addWayDynP :: Way -> DynP ()
addWayDynP :: Way -> DynP ()
addWayDynP = (DynFlags -> DynFlags) -> DynP ()
upd forall b c a. (b -> c) -> (a -> b) -> a -> c
. Way -> DynFlags -> DynFlags
addWay'

addWay' :: Way -> DynFlags -> DynFlags
addWay' :: Way -> DynFlags -> DynFlags
addWay' Way
w DynFlags
dflags0 =
   let platform :: Platform
platform = DynFlags -> Platform
targetPlatform DynFlags
dflags0
       dflags1 :: DynFlags
dflags1 = DynFlags
dflags0 { targetWays_ :: Ways
targetWays_ = Way -> Ways -> Ways
addWay Way
w (DynFlags -> Ways
targetWays_ DynFlags
dflags0) }
       dflags2 :: DynFlags
dflags2 = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' DynFlags
dflags1
                       (Platform -> Way -> [GeneralFlag]
wayGeneralFlags Platform
platform Way
w)
       dflags3 :: DynFlags
dflags3 = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' DynFlags
dflags2
                       (Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags Platform
platform Way
w)
   in DynFlags
dflags3

removeWayDyn :: DynP ()
removeWayDyn :: DynP ()
removeWayDyn = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags
dfs { targetWays_ :: Ways
targetWays_ = Way -> Ways -> Ways
removeWay Way
WayDyn (DynFlags -> Ways
targetWays_ DynFlags
dfs) })

--------------------------
setGeneralFlag, unSetGeneralFlag :: GeneralFlag -> DynP ()
setGeneralFlag :: GeneralFlag -> DynP ()
setGeneralFlag   GeneralFlag
f = (DynFlags -> DynFlags) -> DynP ()
upd (GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' GeneralFlag
f)
unSetGeneralFlag :: GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
f = (DynFlags -> DynFlags) -> DynP ()
upd (GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' GeneralFlag
f)

setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' GeneralFlag
f DynFlags
dflags = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a b. (a -> b) -> a -> b
($) (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dflags GeneralFlag
f) [DynFlags -> DynFlags]
deps
  where
    deps :: [DynFlags -> DynFlags]
deps = [ if Bool
turn_on then GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag'   GeneralFlag
d
                        else GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' GeneralFlag
d
           | (GeneralFlag
f', Bool
turn_on, GeneralFlag
d) <- [(GeneralFlag, Bool, GeneralFlag)]
impliedGFlags, GeneralFlag
f' forall a. Eq a => a -> a -> Bool
== GeneralFlag
f ]
        -- When you set f, set the ones it implies
        -- NB: use setGeneralFlag recursively, in case the implied flags
        --     implies further flags

unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' :: GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' GeneralFlag
f DynFlags
dflags = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a b. (a -> b) -> a -> b
($) (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
f) [DynFlags -> DynFlags]
deps
  where
    deps :: [DynFlags -> DynFlags]
deps = [ if Bool
turn_on then GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' GeneralFlag
d
                        else GeneralFlag -> DynFlags -> DynFlags
unSetGeneralFlag' GeneralFlag
d
           | (GeneralFlag
f', Bool
turn_on, GeneralFlag
d) <- [(GeneralFlag, Bool, GeneralFlag)]
impliedOffGFlags, GeneralFlag
f' forall a. Eq a => a -> a -> Bool
== GeneralFlag
f ]
   -- In general, when you un-set f, we don't un-set the things it implies.
   -- There are however some exceptions, e.g., -fno-strictness implies
   -- -fno-worker-wrapper.
   --
   -- NB: use unSetGeneralFlag' recursively, in case the implied off flags
   --     imply further flags.

--------------------------
setWarningFlag, unSetWarningFlag :: WarningFlag -> DynP ()
setWarningFlag :: WarningFlag -> DynP ()
setWarningFlag   WarningFlag
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningFlag -> DynFlags
wopt_set DynFlags
dfs WarningFlag
f)
unSetWarningFlag :: WarningFlag -> DynP ()
unSetWarningFlag WarningFlag
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningFlag -> DynFlags
wopt_unset DynFlags
dfs WarningFlag
f)

setFatalWarningFlag, unSetFatalWarningFlag :: WarningFlag -> DynP ()
setFatalWarningFlag :: WarningFlag -> DynP ()
setFatalWarningFlag   WarningFlag
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningFlag -> DynFlags
wopt_set_fatal DynFlags
dfs WarningFlag
f)
unSetFatalWarningFlag :: WarningFlag -> DynP ()
unSetFatalWarningFlag WarningFlag
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningFlag -> DynFlags
wopt_unset_fatal DynFlags
dfs WarningFlag
f)

setWErrorFlag :: WarningFlag -> DynP ()
setWErrorFlag :: WarningFlag -> DynP ()
setWErrorFlag WarningFlag
flag =
  do { WarningFlag -> DynP ()
setWarningFlag WarningFlag
flag
     ; WarningFlag -> DynP ()
setFatalWarningFlag WarningFlag
flag }

--------------------------
setExtensionFlag, unSetExtensionFlag :: LangExt.Extension -> DynP ()
setExtensionFlag :: Extension -> DynP ()
setExtensionFlag Extension
f = (DynFlags -> DynFlags) -> DynP ()
upd (Extension -> DynFlags -> DynFlags
setExtensionFlag' Extension
f)
unSetExtensionFlag :: Extension -> DynP ()
unSetExtensionFlag Extension
f = (DynFlags -> DynFlags) -> DynP ()
upd (Extension -> DynFlags -> DynFlags
unSetExtensionFlag' Extension
f)

setExtensionFlag', unSetExtensionFlag' :: LangExt.Extension -> DynFlags -> DynFlags
setExtensionFlag' :: Extension -> DynFlags -> DynFlags
setExtensionFlag' Extension
f DynFlags
dflags = forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr forall a b. (a -> b) -> a -> b
($) (DynFlags -> Extension -> DynFlags
xopt_set DynFlags
dflags Extension
f) [DynFlags -> DynFlags]
deps
  where
    deps :: [DynFlags -> DynFlags]
deps = [ if Bool
turn_on then Extension -> DynFlags -> DynFlags
setExtensionFlag'   Extension
d
                        else Extension -> DynFlags -> DynFlags
unSetExtensionFlag' Extension
d
           | (Extension
f', Bool
turn_on, Extension
d) <- [(Extension, Bool, Extension)]
impliedXFlags, Extension
f' forall a. Eq a => a -> a -> Bool
== Extension
f ]
        -- When you set f, set the ones it implies
        -- NB: use setExtensionFlag recursively, in case the implied flags
        --     implies further flags

unSetExtensionFlag' :: Extension -> DynFlags -> DynFlags
unSetExtensionFlag' Extension
f DynFlags
dflags = DynFlags -> Extension -> DynFlags
xopt_unset DynFlags
dflags Extension
f
   -- When you un-set f, however, we don't un-set the things it implies
   --      (except for -fno-glasgow-exts, which is treated specially)

--------------------------

alterToolSettings :: (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings :: (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ToolSettings -> ToolSettings
f DynFlags
dynFlags = DynFlags
dynFlags { toolSettings :: ToolSettings
toolSettings = ToolSettings -> ToolSettings
f (DynFlags -> ToolSettings
toolSettings DynFlags
dynFlags) }

--------------------------
setDumpFlag' :: DumpFlag -> DynP ()
setDumpFlag' :: DumpFlag -> DynP ()
setDumpFlag' DumpFlag
dump_flag
  = do (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> DumpFlag -> DynFlags
dopt_set DynFlags
dfs DumpFlag
dump_flag)
       forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when Bool
want_recomp DynP ()
forceRecompile
    where -- Certain dumpy-things are really interested in what's going
          -- on during recompilation checking, so in those cases we
          -- don't want to turn it off.
          want_recomp :: Bool
want_recomp = DumpFlag
dump_flag forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`notElem` [DumpFlag
Opt_D_dump_if_trace,
                                             DumpFlag
Opt_D_dump_hi_diffs,
                                             DumpFlag
Opt_D_no_debug_output]

forceRecompile :: DynP ()
-- Whenever we -ddump, force recompilation (by switching off the
-- recompilation checker), else you don't see the dump! However,
-- don't switch it off in --make mode, else *everything* gets
-- recompiled which probably isn't what you want
forceRecompile :: DynP ()
forceRecompile = do DynFlags
dfs <- forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM forall s. CmdLineP s s
getCmdLineState
                    forall (f :: * -> *). Applicative f => Bool -> f () -> f ()
when (DynFlags -> Bool
force_recomp DynFlags
dfs) (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_ForceRecomp)
        where
          force_recomp :: DynFlags -> Bool
force_recomp DynFlags
dfs = GhcMode -> Bool
isOneShot (DynFlags -> GhcMode
ghcMode DynFlags
dfs)


setVerbosity :: Maybe Int -> DynP ()
setVerbosity :: Maybe Int -> DynP ()
setVerbosity Maybe Int
mb_n = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags
dfs{ verbosity :: Int
verbosity = Maybe Int
mb_n forall a. Maybe a -> a -> a
`orElse` Int
3 })

setDebugLevel :: Maybe Int -> DynP ()
setDebugLevel :: Maybe Int -> DynP ()
setDebugLevel Maybe Int
mb_n =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> DynFlags
exposeSyms forall a b. (a -> b) -> a -> b
$ DynFlags
dfs{ debugLevel :: Int
debugLevel = Int
n })
  where
    n :: Int
n = Maybe Int
mb_n forall a. Maybe a -> a -> a
`orElse` Int
2
    exposeSyms :: DynFlags -> DynFlags
exposeSyms
      | Int
n forall a. Ord a => a -> a -> Bool
> Int
2     = GeneralFlag -> DynFlags -> DynFlags
setGeneralFlag' GeneralFlag
Opt_ExposeInternalSymbols
      | Bool
otherwise = forall a. a -> a
id

data PkgDbRef
  = GlobalPkgDb
  | UserPkgDb
  | PkgDbPath FilePath
  deriving PkgDbRef -> PkgDbRef -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PkgDbRef -> PkgDbRef -> Bool
$c/= :: PkgDbRef -> PkgDbRef -> Bool
== :: PkgDbRef -> PkgDbRef -> Bool
$c== :: PkgDbRef -> PkgDbRef -> Bool
Eq

addPkgDbRef :: PkgDbRef -> DynP ()
addPkgDbRef :: PkgDbRef -> DynP ()
addPkgDbRef PkgDbRef
p = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
s ->
  DynFlags
s { packageDBFlags :: [PackageDBFlag]
packageDBFlags = PkgDbRef -> PackageDBFlag
PackageDB PkgDbRef
p forall a. a -> [a] -> [a]
: DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
s }

removeUserPkgDb :: DynP ()
removeUserPkgDb :: DynP ()
removeUserPkgDb = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
s ->
  DynFlags
s { packageDBFlags :: [PackageDBFlag]
packageDBFlags = PackageDBFlag
NoUserPackageDB forall a. a -> [a] -> [a]
: DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
s }

removeGlobalPkgDb :: DynP ()
removeGlobalPkgDb :: DynP ()
removeGlobalPkgDb = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
s ->
 DynFlags
s { packageDBFlags :: [PackageDBFlag]
packageDBFlags = PackageDBFlag
NoGlobalPackageDB forall a. a -> [a] -> [a]
: DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
s }

clearPkgDb :: DynP ()
clearPkgDb :: DynP ()
clearPkgDb = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
s ->
  DynFlags
s { packageDBFlags :: [PackageDBFlag]
packageDBFlags = PackageDBFlag
ClearPackageDBs forall a. a -> [a] -> [a]
: DynFlags -> [PackageDBFlag]
packageDBFlags DynFlags
s }

parsePackageFlag :: String                 -- the flag
                 -> ReadP PackageArg       -- type of argument
                 -> String                 -- string to parse
                 -> PackageFlag
parsePackageFlag :: [Char] -> ReadP PackageArg -> [Char] -> PackageFlag
parsePackageFlag [Char]
flag ReadP PackageArg
arg_parse [Char]
str
 = case forall a. (a -> Bool) -> [a] -> [a]
filter ((forall a. Eq a => a -> a -> Bool
==[Char]
"")forall b c a. (b -> c) -> (a -> b) -> a -> c
.forall a b. (a, b) -> b
snd) (forall a. ReadP a -> ReadS a
readP_to_S ReadP PackageFlag
parse [Char]
str) of
    [(PackageFlag
r, [Char]
"")] -> PackageFlag
r
    [(PackageFlag, [Char])]
_ -> forall a. GhcException -> a
throwGhcException forall a b. (a -> b) -> a -> b
$ [Char] -> GhcException
CmdLineError ([Char]
"Can't parse package flag: " forall a. [a] -> [a] -> [a]
++ [Char]
str)
  where doc :: [Char]
doc = [Char]
flag forall a. [a] -> [a] -> [a]
++ [Char]
" " forall a. [a] -> [a] -> [a]
++ [Char]
str
        parse :: ReadP PackageFlag
parse = do
            PackageArg
pkg_arg <- forall {b}. ReadP b -> ReadP b
tok ReadP PackageArg
arg_parse
            let mk_expose :: ModRenaming -> PackageFlag
mk_expose = [Char] -> PackageArg -> ModRenaming -> PackageFlag
ExposePackage [Char]
doc PackageArg
pkg_arg
            ( do [Char]
_ <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ [Char] -> ReadP [Char]
string [Char]
"with"
                 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ModRenaming -> PackageFlag
mk_expose forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> [(ModuleName, ModuleName)] -> ModRenaming
ModRenaming Bool
True) ReadP [(ModuleName, ModuleName)]
parseRns
             forall a. ReadP a -> ReadP a -> ReadP a
<++ forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (ModRenaming -> PackageFlag
mk_expose forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> [(ModuleName, ModuleName)] -> ModRenaming
ModRenaming Bool
False) ReadP [(ModuleName, ModuleName)]
parseRns
             forall a. ReadP a -> ReadP a -> ReadP a
<++ forall (m :: * -> *) a. Monad m => a -> m a
return (ModRenaming -> PackageFlag
mk_expose (Bool -> [(ModuleName, ModuleName)] -> ModRenaming
ModRenaming Bool
True [])))
        parseRns :: ReadP [(ModuleName, ModuleName)]
parseRns = do Char
_ <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ Char -> ReadP Char
R.char Char
'('
                      [(ModuleName, ModuleName)]
rns <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ forall a sep. ReadP a -> ReadP sep -> ReadP [a]
sepBy ReadP (ModuleName, ModuleName)
parseItem (forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ Char -> ReadP Char
R.char Char
',')
                      Char
_ <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ Char -> ReadP Char
R.char Char
')'
                      forall (m :: * -> *) a. Monad m => a -> m a
return [(ModuleName, ModuleName)]
rns
        parseItem :: ReadP (ModuleName, ModuleName)
parseItem = do
            ModuleName
orig <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ ReadP ModuleName
parseModuleName
            (do [Char]
_ <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ [Char] -> ReadP [Char]
string [Char]
"as"
                ModuleName
new <- forall {b}. ReadP b -> ReadP b
tok forall a b. (a -> b) -> a -> b
$ ReadP ModuleName
parseModuleName
                forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
orig, ModuleName
new)
              forall a. ReadP a -> ReadP a -> ReadP a
+++
             forall (m :: * -> *) a. Monad m => a -> m a
return (ModuleName
orig, ModuleName
orig))
        tok :: ReadP b -> ReadP b
tok ReadP b
m = ReadP b
m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \b
x -> ReadP ()
skipSpaces forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return b
x

exposePackage, exposePackageId, hidePackage,
        exposePluginPackage, exposePluginPackageId,
        ignorePackage,
        trustPackage, distrustPackage :: String -> DynP ()
exposePackage :: [Char] -> DynP ()
exposePackage [Char]
p = (DynFlags -> DynFlags) -> DynP ()
upd ([Char] -> DynFlags -> DynFlags
exposePackage' [Char]
p)
exposePackageId :: [Char] -> DynP ()
exposePackageId [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ packageFlags :: [PackageFlag]
packageFlags =
    [Char] -> ReadP PackageArg -> [Char] -> PackageFlag
parsePackageFlag [Char]
"-package-id" ReadP PackageArg
parseUnitArg [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [PackageFlag]
packageFlags DynFlags
s })
exposePluginPackage :: [Char] -> DynP ()
exposePluginPackage [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ pluginPackageFlags :: [PackageFlag]
pluginPackageFlags =
    [Char] -> ReadP PackageArg -> [Char] -> PackageFlag
parsePackageFlag [Char]
"-plugin-package" ReadP PackageArg
parsePackageArg [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
s })
exposePluginPackageId :: [Char] -> DynP ()
exposePluginPackageId [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ pluginPackageFlags :: [PackageFlag]
pluginPackageFlags =
    [Char] -> ReadP PackageArg -> [Char] -> PackageFlag
parsePackageFlag [Char]
"-plugin-package-id" ReadP PackageArg
parseUnitArg [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [PackageFlag]
pluginPackageFlags DynFlags
s })
hidePackage :: [Char] -> DynP ()
hidePackage [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ packageFlags :: [PackageFlag]
packageFlags = [Char] -> PackageFlag
HidePackage [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [PackageFlag]
packageFlags DynFlags
s })
ignorePackage :: [Char] -> DynP ()
ignorePackage [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ ignorePackageFlags :: [IgnorePackageFlag]
ignorePackageFlags = [Char] -> IgnorePackageFlag
IgnorePackage [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [IgnorePackageFlag]
ignorePackageFlags DynFlags
s })

trustPackage :: [Char] -> DynP ()
trustPackage [Char]
p = [Char] -> DynP ()
exposePackage [Char]
p forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> -- both trust and distrust also expose a package
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ trustFlags :: [TrustFlag]
trustFlags = [Char] -> TrustFlag
TrustPackage [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [TrustFlag]
trustFlags DynFlags
s })
distrustPackage :: [Char] -> DynP ()
distrustPackage [Char]
p = [Char] -> DynP ()
exposePackage [Char]
p forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>>
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ trustFlags :: [TrustFlag]
trustFlags = [Char] -> TrustFlag
DistrustPackage [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [TrustFlag]
trustFlags DynFlags
s })

exposePackage' :: String -> DynFlags -> DynFlags
exposePackage' :: [Char] -> DynFlags -> DynFlags
exposePackage' [Char]
p DynFlags
dflags
    = DynFlags
dflags { packageFlags :: [PackageFlag]
packageFlags =
            [Char] -> ReadP PackageArg -> [Char] -> PackageFlag
parsePackageFlag [Char]
"-package" ReadP PackageArg
parsePackageArg [Char]
p forall a. a -> [a] -> [a]
: DynFlags -> [PackageFlag]
packageFlags DynFlags
dflags }

parsePackageArg :: ReadP PackageArg
parsePackageArg :: ReadP PackageArg
parsePackageArg =
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Char] -> PackageArg
PackageArg ((Char -> Bool) -> ReadP [Char]
munch1 (\Char
c -> Char -> Bool
isAlphaNum Char
c Bool -> Bool -> Bool
|| Char
c forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
`elem` [Char]
":-_."))

parseUnitArg :: ReadP PackageArg
parseUnitArg :: ReadP PackageArg
parseUnitArg =
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Unit -> PackageArg
UnitIdArg ReadP Unit
parseUnit

setUnitId :: String -> DynFlags -> DynFlags
setUnitId :: [Char] -> DynFlags -> DynFlags
setUnitId [Char]
p DynFlags
d = DynFlags
d { homeUnitId_ :: UnitId
homeUnitId_ = [Char] -> UnitId
stringToUnitId [Char]
p }

setWorkingDirectory :: String -> DynFlags -> DynFlags
setWorkingDirectory :: [Char] -> DynFlags -> DynFlags
setWorkingDirectory [Char]
p DynFlags
d = DynFlags
d { workingDirectory :: Maybe [Char]
workingDirectory =  forall a. a -> Maybe a
Just [Char]
p }

{-
Note [Filepaths and Multiple Home Units]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

It is common to assume that a package is compiled in the directory where its
cabal file resides. Thus, all paths used in the compiler are assumed to be relative
to this directory. When there are multiple home units the compiler is often
not operating in the standard directory and instead where the cabal.project
file is located. In this case the `-working-dir` option can be passed which specifies
the path from the current directory to the directory the unit assumes to be it's root,
normally the directory which contains the cabal file.

When the flag is passed, any relative paths used by the compiler are offset
by the working directory. Notably this includes `-i`, `-I⟨dir⟩`, `-hidir`, `-odir` etc and
the location of input files.

-}

augmentByWorkingDirectory :: DynFlags -> FilePath -> FilePath
augmentByWorkingDirectory :: DynFlags -> ShowS
augmentByWorkingDirectory DynFlags
dflags [Char]
fp | [Char] -> Bool
isRelative [Char]
fp, Just [Char]
offset <- DynFlags -> Maybe [Char]
workingDirectory DynFlags
dflags = [Char]
offset [Char] -> ShowS
</> [Char]
fp
augmentByWorkingDirectory DynFlags
_ [Char]
fp = [Char]
fp

setPackageName :: String -> DynFlags -> DynFlags
setPackageName :: [Char] -> DynFlags -> DynFlags
setPackageName [Char]
p DynFlags
d = DynFlags
d { thisPackageName :: Maybe [Char]
thisPackageName =  forall a. a -> Maybe a
Just [Char]
p }

addHiddenModule :: String -> DynP ()
addHiddenModule :: [Char] -> DynP ()
addHiddenModule [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ hiddenModules :: Set ModuleName
hiddenModules  = forall a. Ord a => a -> Set a -> Set a
Set.insert ([Char] -> ModuleName
mkModuleName [Char]
p) (DynFlags -> Set ModuleName
hiddenModules DynFlags
s) })

addReexportedModule :: String -> DynP ()
addReexportedModule :: [Char] -> DynP ()
addReexportedModule [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ reexportedModules :: Set ModuleName
reexportedModules  = forall a. Ord a => a -> Set a -> Set a
Set.insert ([Char] -> ModuleName
mkModuleName [Char]
p) (DynFlags -> Set ModuleName
reexportedModules DynFlags
s) })


-- If we're linking a binary, then only backends that produce object
-- code are allowed (requests for other target types are ignored).
setBackend :: Backend -> DynP ()
setBackend :: Backend -> DynP ()
setBackend Backend
l = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \ DynFlags
dfs ->
  if DynFlags -> GhcLink
ghcLink DynFlags
dfs forall a. Eq a => a -> a -> Bool
/= GhcLink
LinkBinary Bool -> Bool -> Bool
|| Backend -> Bool
backendWritesFiles Backend
l
  then DynFlags
dfs{ backend :: Backend
backend = Backend
l }
  else DynFlags
dfs

-- Changes the target only if we're compiling object code.  This is
-- used by -fasm and -fllvm, which switch from one to the other, but
-- not from bytecode to object-code.  The idea is that -fasm/-fllvm
-- can be safely used in an OPTIONS_GHC pragma.
setObjBackend :: Backend -> DynP ()
setObjBackend :: Backend -> DynP ()
setObjBackend Backend
l = (DynFlags -> DynP DynFlags) -> DynP ()
updM DynFlags -> DynP DynFlags
set
  where
   set :: DynFlags -> DynP DynFlags
set DynFlags
dflags
     | Backend -> Bool
backendWritesFiles (DynFlags -> Backend
backend DynFlags
dflags)
       = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ DynFlags
dflags { backend :: Backend
backend = Backend
l }
     | Bool
otherwise = forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags

setOptLevel :: Int -> DynFlags -> DynP DynFlags
setOptLevel :: Int -> DynFlags -> DynP DynFlags
setOptLevel Int
n DynFlags
dflags = forall (m :: * -> *) a. Monad m => a -> m a
return (Int -> DynFlags -> DynFlags
updOptLevel Int
n DynFlags
dflags)

setCallerCcFilters :: String -> DynP ()
setCallerCcFilters :: [Char] -> DynP ()
setCallerCcFilters [Char]
arg =
  case [Char] -> Either [Char] CallerCcFilter
parseCallerCcFilter [Char]
arg of
    Right CallerCcFilter
filt -> (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { callerCcFilters :: [CallerCcFilter]
callerCcFilters = CallerCcFilter
filt forall a. a -> [a] -> [a]
: DynFlags -> [CallerCcFilter]
callerCcFilters DynFlags
d }
    Left [Char]
err -> forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addErr [Char]
err

setMainIs :: String -> DynP ()
setMainIs :: [Char] -> DynP ()
setMainIs [Char]
arg
  | Char
x:[Char]
_ <- [Char]
main_fn, Char -> Bool
isLower Char
x  -- The arg looked like "Foo.Bar.baz"
  = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainFunIs :: Maybe [Char]
mainFunIs = forall a. a -> Maybe a
Just [Char]
main_fn,
                    mainModuleNameIs :: ModuleName
mainModuleNameIs = [Char] -> ModuleName
mkModuleName [Char]
main_mod }

  | Char
x:[Char]
_ <- [Char]
arg, Char -> Bool
isUpper Char
x  -- The arg looked like "Foo" or "Foo.Bar"
  = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainModuleNameIs :: ModuleName
mainModuleNameIs = [Char] -> ModuleName
mkModuleName [Char]
arg }

  | Bool
otherwise                   -- The arg looked like "baz"
  = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainFunIs :: Maybe [Char]
mainFunIs = forall a. a -> Maybe a
Just [Char]
arg }
  where
    ([Char]
main_mod, [Char]
main_fn) = [Char] -> (Char -> Bool) -> ([Char], [Char])
splitLongestPrefix [Char]
arg (forall a. Eq a => a -> a -> Bool
== Char
'.')

addLdInputs :: Option -> DynFlags -> DynFlags
addLdInputs :: Option -> DynFlags -> DynFlags
addLdInputs Option
p DynFlags
dflags = DynFlags
dflags{ldInputs :: [Option]
ldInputs = DynFlags -> [Option]
ldInputs DynFlags
dflags forall a. [a] -> [a] -> [a]
++ [Option
p]}

-- -----------------------------------------------------------------------------
-- Load dynflags from environment files.

setFlagsFromEnvFile :: FilePath -> String -> DynP ()
setFlagsFromEnvFile :: [Char] -> [Char] -> DynP ()
setFlagsFromEnvFile [Char]
envfile [Char]
content = do
  GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_HideAllPackages
  [Char] -> [Char] -> DynP ()
parseEnvFile [Char]
envfile [Char]
content

parseEnvFile :: FilePath -> String -> DynP ()
parseEnvFile :: [Char] -> [Char] -> DynP ()
parseEnvFile [Char]
envfile = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ [Char] -> DynP ()
parseEntry forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> [[Char]]
lines
  where
    parseEntry :: [Char] -> DynP ()
parseEntry [Char]
str = case [Char] -> [[Char]]
words [Char]
str of
      ([Char]
"package-db": [[Char]]
_)     -> PkgDbRef -> DynP ()
addPkgDbRef ([Char] -> PkgDbRef
PkgDbPath ([Char]
envdir [Char] -> ShowS
</> [Char]
db))
        -- relative package dbs are interpreted relative to the env file
        where envdir :: [Char]
envdir = ShowS
takeDirectory [Char]
envfile
              db :: [Char]
db     = forall a. Int -> [a] -> [a]
drop Int
11 [Char]
str
      [[Char]
"clear-package-db"]  -> DynP ()
clearPkgDb
      [[Char]
"hide-package", [Char]
pkg]  -> [Char] -> DynP ()
hidePackage [Char]
pkg
      [[Char]
"global-package-db"] -> PkgDbRef -> DynP ()
addPkgDbRef PkgDbRef
GlobalPkgDb
      [[Char]
"user-package-db"]   -> PkgDbRef -> DynP ()
addPkgDbRef PkgDbRef
UserPkgDb
      [[Char]
"package-id", [Char]
pkgid] -> [Char] -> DynP ()
exposePackageId [Char]
pkgid
      ((Char
'-':Char
'-':[Char]
_):[[Char]]
_)       -> forall (m :: * -> *) a. Monad m => a -> m a
return () -- comments
      -- and the original syntax introduced in 7.10:
      [[Char]
pkgid]               -> [Char] -> DynP ()
exposePackageId [Char]
pkgid
      []                    -> forall (m :: * -> *) a. Monad m => a -> m a
return ()
      [[Char]]
_                     -> forall a. GhcException -> a
throwGhcException forall a b. (a -> b) -> a -> b
$ [Char] -> GhcException
CmdLineError forall a b. (a -> b) -> a -> b
$
                                    [Char]
"Can't parse environment file entry: "
                                 forall a. [a] -> [a] -> [a]
++ [Char]
envfile forall a. [a] -> [a] -> [a]
++ [Char]
": " forall a. [a] -> [a] -> [a]
++ [Char]
str


-----------------------------------------------------------------------------
-- Paths & Libraries

addImportPath, addLibraryPath, addIncludePath, addFrameworkPath :: FilePath -> DynP ()

-- -i on its own deletes the import paths
addImportPath :: [Char] -> DynP ()
addImportPath [Char]
"" = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{importPaths :: [[Char]]
importPaths = []})
addImportPath [Char]
p  = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{importPaths :: [[Char]]
importPaths = DynFlags -> [[Char]]
importPaths DynFlags
s forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]]
splitPathList [Char]
p})

addLibraryPath :: [Char] -> DynP ()
addLibraryPath [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{libraryPaths :: [[Char]]
libraryPaths = DynFlags -> [[Char]]
libraryPaths DynFlags
s forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]]
splitPathList [Char]
p})

addIncludePath :: [Char] -> DynP ()
addIncludePath [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{includePaths :: IncludeSpecs
includePaths =
                  IncludeSpecs -> [[Char]] -> IncludeSpecs
addGlobalInclude (DynFlags -> IncludeSpecs
includePaths DynFlags
s) ([Char] -> [[Char]]
splitPathList [Char]
p)})

addFrameworkPath :: [Char] -> DynP ()
addFrameworkPath [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{frameworkPaths :: [[Char]]
frameworkPaths = DynFlags -> [[Char]]
frameworkPaths DynFlags
s forall a. [a] -> [a] -> [a]
++ [Char] -> [[Char]]
splitPathList [Char]
p})

#if !defined(mingw32_HOST_OS)
split_marker :: Char
split_marker :: Char
split_marker = Char
':'   -- not configurable (ToDo)
#endif

splitPathList :: String -> [String]
splitPathList :: [Char] -> [[Char]]
splitPathList [Char]
s = forall a. (a -> Bool) -> [a] -> [a]
filter forall (f :: * -> *) a. Foldable f => f a -> Bool
notNull ([Char] -> [[Char]]
splitUp [Char]
s)
                -- empty paths are ignored: there might be a trailing
                -- ':' in the initial list, for example.  Empty paths can
                -- cause confusion when they are translated into -I options
                -- for passing to gcc.
  where
#if !defined(mingw32_HOST_OS)
    splitUp :: [Char] -> [[Char]]
splitUp [Char]
xs = Char -> [Char] -> [[Char]]
split Char
split_marker [Char]
xs
#else
     -- Windows: 'hybrid' support for DOS-style paths in directory lists.
     --
     -- That is, if "foo:bar:baz" is used, this interpreted as
     -- consisting of three entries, 'foo', 'bar', 'baz'.
     -- However, with "c:/foo:c:\\foo;x:/bar", this is interpreted
     -- as 3 elts, "c:/foo", "c:\\foo", "x:/bar"
     --
     -- Notice that no attempt is made to fully replace the 'standard'
     -- split marker ':' with the Windows / DOS one, ';'. The reason being
     -- that this will cause too much breakage for users & ':' will
     -- work fine even with DOS paths, if you're not insisting on being silly.
     -- So, use either.
    splitUp []             = []
    splitUp (x:':':div:xs) | div `elem` dir_markers
                           = ((x:':':div:p): splitUp rs)
                           where
                              (p,rs) = findNextPath xs
          -- we used to check for existence of the path here, but that
          -- required the IO monad to be threaded through the command-line
          -- parser which is quite inconvenient.  The
    splitUp xs = cons p (splitUp rs)
               where
                 (p,rs) = findNextPath xs

                 cons "" xs = xs
                 cons x  xs = x:xs

    -- will be called either when we've consumed nought or the
    -- "<Drive>:/" part of a DOS path, so splitting is just a Q of
    -- finding the next split marker.
    findNextPath xs =
        case break (`elem` split_markers) xs of
           (p, _:ds) -> (p, ds)
           (p, xs)   -> (p, xs)

    split_markers :: [Char]
    split_markers = [':', ';']

    dir_markers :: [Char]
    dir_markers = ['/', '\\']
#endif

-- -----------------------------------------------------------------------------
-- tmpDir, where we store temporary files.

setTmpDir :: FilePath -> DynFlags -> DynFlags
setTmpDir :: [Char] -> DynFlags -> DynFlags
setTmpDir [Char]
dir DynFlags
d = DynFlags
d { tmpDir :: TempDir
tmpDir = [Char] -> TempDir
TempDir (ShowS
normalise [Char]
dir) }
  -- we used to fix /cygdrive/c/.. on Windows, but this doesn't
  -- seem necessary now --SDM 7/2/2008

-----------------------------------------------------------------------------
-- RTS opts

setRtsOpts :: String -> DynP ()
setRtsOpts :: [Char] -> DynP ()
setRtsOpts [Char]
arg  = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \ DynFlags
d -> DynFlags
d {rtsOpts :: Maybe [Char]
rtsOpts = forall a. a -> Maybe a
Just [Char]
arg}

setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
setRtsOptsEnabled :: RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
arg  = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \ DynFlags
d -> DynFlags
d {rtsOptsEnabled :: RtsOptsEnabled
rtsOptsEnabled = RtsOptsEnabled
arg}

-----------------------------------------------------------------------------
-- Hpc stuff

setOptHpcDir :: String -> DynP ()
setOptHpcDir :: [Char] -> DynP ()
setOptHpcDir [Char]
arg  = (DynFlags -> DynFlags) -> DynP ()
upd forall a b. (a -> b) -> a -> b
$ \ DynFlags
d -> DynFlags
d {hpcDir :: [Char]
hpcDir = [Char]
arg}

-----------------------------------------------------------------------------
-- Via-C compilation stuff

-- There are some options that we need to pass to gcc when compiling
-- Haskell code via C, but are only supported by recent versions of
-- gcc.  The configure script decides which of these options we need,
-- and puts them in the "settings" file in $topdir. The advantage of
-- having these in a separate file is that the file can be created at
-- install-time depending on the available gcc version, and even
-- re-generated later if gcc is upgraded.
--
-- The options below are not dependent on the version of gcc, only the
-- platform.

picCCOpts :: DynFlags -> [String]
picCCOpts :: DynFlags -> [[Char]]
picCCOpts DynFlags
dflags =
      case Platform -> OS
platformOS (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
      OS
OSDarwin
          -- Apple prefers to do things the other way round.
          -- PIC is on by default.
          -- -mdynamic-no-pic:
          --     Turn off PIC code generation.
          -- -fno-common:
          --     Don't generate "common" symbols - these are unwanted
          --     in dynamic libraries.

       | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags -> [[Char]
"-fno-common", [Char]
"-U__PIC__", [Char]
"-D__PIC__"]
       | Bool
otherwise           -> [[Char]
"-mdynamic-no-pic"]
      OS
OSMinGW32 -- no -fPIC for Windows
       | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags -> [[Char]
"-U__PIC__", [Char]
"-D__PIC__"]
       | Bool
otherwise           -> []
      OS
_
      -- we need -fPIC for C files when we are compiling with -dynamic,
      -- otherwise things like stub.c files don't get compiled
      -- correctly.  They need to reference data in the Haskell
      -- objects, but can't without -fPIC.  See
      -- https://gitlab.haskell.org/ghc/ghc/wikis/commentary/position-independent-code
       | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags Bool -> Bool -> Bool
|| DynFlags -> Ways
ways DynFlags
dflags Ways -> Way -> Bool
`hasWay` Way
WayDyn ->
          [[Char]
"-fPIC", [Char]
"-U__PIC__", [Char]
"-D__PIC__"]
      -- gcc may be configured to have PIC on by default, let's be
      -- explicit here, see #15847
       | Bool
otherwise -> [[Char]
"-fno-PIC"]

pieCCLDOpts :: DynFlags -> [String]
pieCCLDOpts :: DynFlags -> [[Char]]
pieCCLDOpts DynFlags
dflags
      | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PICExecutable DynFlags
dflags       = [[Char]
"-pie"]
        -- See Note [No PIE when linking]
      | ToolSettings -> Bool
toolSettings_ccSupportsNoPie (DynFlags -> ToolSettings
toolSettings DynFlags
dflags) = [[Char]
"-no-pie"]
      | Bool
otherwise                           = []


{-
Note [No PIE when linking]
~~~~~~~~~~~~~~~~~~~~~~~~~~
As of 2016 some Linux distributions (e.g. Debian) have started enabling -pie by
default in their gcc builds. This is incompatible with -r as it implies that we
are producing an executable. Consequently, we must manually pass -no-pie to gcc
when joining object files or linking dynamic libraries. Unless, of course, the
user has explicitly requested a PIE executable with -pie. See #12759.
-}

picPOpts :: DynFlags -> [String]
picPOpts :: DynFlags -> [[Char]]
picPOpts DynFlags
dflags
 | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags = [[Char]
"-U__PIC__", [Char]
"-D__PIC__"]
 | Bool
otherwise           = []

-- -----------------------------------------------------------------------------
-- Compiler Info

compilerInfo :: DynFlags -> [(String, String)]
compilerInfo :: DynFlags -> [([Char], [Char])]
compilerInfo DynFlags
dflags
    = -- We always make "Project name" be first to keep parsing in
      -- other languages simple, i.e. when looking for other fields,
      -- you don't have to worry whether there is a leading '[' or not
      ([Char]
"Project name",                 [Char]
cProjectName)
      -- Next come the settings, so anything else can be overridden
      -- in the settings file (as "lookup" uses the first match for the
      -- key)
    forall a. a -> [a] -> [a]
: forall a b. (a -> b) -> [a] -> [b]
map (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a b. (a -> b) -> a -> b
$ [Char] -> Maybe [Char] -> ShowS
expandDirectories (DynFlags -> [Char]
topDir DynFlags
dflags) (DynFlags -> Maybe [Char]
toolDir DynFlags
dflags))
          (DynFlags -> [([Char], [Char])]
rawSettings DynFlags
dflags)
   forall a. [a] -> [a] -> [a]
++ [([Char]
"Project version",             DynFlags -> [Char]
projectVersion DynFlags
dflags),
       ([Char]
"Project Git commit id",       [Char]
cProjectGitCommitId),
       ([Char]
"Project Version Int",         [Char]
cProjectVersionInt),
       ([Char]
"Project Patch Level",         [Char]
cProjectPatchLevel),
       ([Char]
"Project Patch Level1",        [Char]
cProjectPatchLevel1),
       ([Char]
"Project Patch Level2",        [Char]
cProjectPatchLevel2),
       ([Char]
"Booter version",              [Char]
cBooterVersion),
       ([Char]
"Stage",                       [Char]
cStage),
       ([Char]
"Build platform",              [Char]
cBuildPlatformString),
       ([Char]
"Host platform",               [Char]
cHostPlatformString),
       ([Char]
"Target platform",             PlatformMisc -> [Char]
platformMisc_targetPlatformString forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags),
       ([Char]
"Have interpreter",            Bool -> [Char]
showBool forall a b. (a -> b) -> a -> b
$ PlatformMisc -> Bool
platformMisc_ghcWithInterpreter forall a b. (a -> b) -> a -> b
$ DynFlags -> PlatformMisc
platformMisc DynFlags
dflags),
       ([Char]
"Object splitting supported",  Bool -> [Char]
showBool Bool
False),
       ([Char]
"Have native code generator",  Bool -> [Char]
showBool forall a b. (a -> b) -> a -> b
$ Platform -> Bool
platformNcgSupported (DynFlags -> Platform
targetPlatform DynFlags
dflags)),
       ([Char]
"Target default backend",      forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ Platform -> Backend
platformDefaultBackend (DynFlags -> Platform
targetPlatform DynFlags
dflags)),
       -- Whether or not we support @-dynamic-too@
       ([Char]
"Support dynamic-too",         Bool -> [Char]
showBool forall a b. (a -> b) -> a -> b
$ Bool -> Bool
not Bool
isWindows),
       -- Whether or not we support the @-j@ flag with @--make@.
       ([Char]
"Support parallel --make",     [Char]
"YES"),
       -- Whether or not we support "Foo from foo-0.1-XXX:Foo" syntax in
       -- installed package info.
       ([Char]
"Support reexported-modules",  [Char]
"YES"),
       -- Whether or not we support extended @-package foo (Foo)@ syntax.
       ([Char]
"Support thinning and renaming package flags", [Char]
"YES"),
       -- Whether or not we support Backpack.
       ([Char]
"Support Backpack", [Char]
"YES"),
       -- If true, we require that the 'id' field in installed package info
       -- match what is passed to the @-this-unit-id@ flag for modules
       -- built in it
       ([Char]
"Requires unified installed package IDs", [Char]
"YES"),
       -- Whether or not we support the @-this-package-key@ flag.  Prefer
       -- "Uses unit IDs" over it. We still say yes even if @-this-package-key@
       -- flag has been removed, otherwise it breaks Cabal...
       ([Char]
"Uses package keys",           [Char]
"YES"),
       -- Whether or not we support the @-this-unit-id@ flag
       ([Char]
"Uses unit IDs",               [Char]
"YES"),
       -- Whether or not GHC was compiled using -dynamic
       ([Char]
"GHC Dynamic",                 Bool -> [Char]
showBool Bool
hostIsDynamic),
       -- Whether or not GHC was compiled using -prof
       ([Char]
"GHC Profiled",                Bool -> [Char]
showBool Bool
hostIsProfiled),
       ([Char]
"Debug on",                    Bool -> [Char]
showBool Bool
debugIsOn),
       ([Char]
"LibDir",                      DynFlags -> [Char]
topDir DynFlags
dflags),
       -- The path of the global package database used by GHC
       ([Char]
"Global Package DB",           DynFlags -> [Char]
globalPackageDatabasePath DynFlags
dflags)
      ]
  where
    showBool :: Bool -> [Char]
showBool Bool
True  = [Char]
"YES"
    showBool Bool
False = [Char]
"NO"
    platform :: Platform
platform  = DynFlags -> Platform
targetPlatform DynFlags
dflags
    isWindows :: Bool
isWindows = Platform -> OS
platformOS Platform
platform forall a. Eq a => a -> a -> Bool
== OS
OSMinGW32
    useInplaceMinGW :: Bool
useInplaceMinGW = ToolSettings -> Bool
toolSettings_useInplaceMinGW forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
    expandDirectories :: FilePath -> Maybe FilePath -> String -> String
    expandDirectories :: [Char] -> Maybe [Char] -> ShowS
expandDirectories [Char]
topd Maybe [Char]
mtoold = Bool -> Maybe [Char] -> ShowS
expandToolDir Bool
useInplaceMinGW Maybe [Char]
mtoold forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> ShowS
expandTopDir [Char]
topd


-- | Get target profile
targetProfile :: DynFlags -> Profile
targetProfile :: DynFlags -> Profile
targetProfile DynFlags
dflags = Platform -> Ways -> Profile
Profile (DynFlags -> Platform
targetPlatform DynFlags
dflags) (DynFlags -> Ways
ways DynFlags
dflags)

{- -----------------------------------------------------------------------------
Note [DynFlags consistency]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~

There are a number of number of DynFlags configurations which either
do not make sense or lead to unimplemented or buggy codepaths in the
compiler. makeDynFlagsConsistent is responsible for verifying the validity
of a set of DynFlags, fixing any issues, and reporting them back to the
caller.

GHCi and -O
---------------

When using optimization, the compiler can introduce several things
(such as unboxed tuples) into the intermediate code, which GHCi later
chokes on since the bytecode interpreter can't handle this (and while
this is arguably a bug these aren't handled, there are no plans to fix
it.)

While the driver pipeline always checks for this particular erroneous
combination when parsing flags, we also need to check when we update
the flags; this is because API clients may parse flags but update the
DynFlags afterwords, before finally running code inside a session (see
T10052 and #10052).
-}

-- | Resolve any internal inconsistencies in a set of 'DynFlags'.
-- Returns the consistent 'DynFlags' as well as a list of warnings
-- to report to the user.
makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located String])
-- Whenever makeDynFlagsConsistent does anything, it starts over, to
-- ensure that a later change doesn't invalidate an earlier check.
-- Be careful not to introduce potential loops!
makeDynFlagsConsistent :: DynFlags -> (DynFlags, [Located [Char]])
makeDynFlagsConsistent DynFlags
dflags
 -- Disable -dynamic-too on Windows (#8228, #7134, #5987)
 | OS
os forall a. Eq a => a -> a -> Bool
== OS
OSMinGW32 Bool -> Bool -> Bool
&& GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_BuildDynamicToo DynFlags
dflags
    = let dflags' :: DynFlags
dflags' = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_BuildDynamicToo
          warn :: [Char]
warn    = [Char]
"-dynamic-too is not supported on Windows"
      in DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' [Char]
warn
 -- Disable -dynamic-too if we are are compiling with -dynamic already, otherwise
 -- you get two dynamic object files (.o and .dyn_o). (#20436)
 | DynFlags -> Ways
ways DynFlags
dflags Ways -> Way -> Bool
`hasWay` Way
WayDyn Bool -> Bool -> Bool
&& GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_BuildDynamicToo DynFlags
dflags
    = let dflags' :: DynFlags
dflags' = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_BuildDynamicToo
          warn :: [Char]
warn = [Char]
"-dynamic-too is ignored when using -dynamic"
      in DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' [Char]
warn

 | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SplitSections DynFlags
dflags
 , Platform -> Bool
platformHasSubsectionsViaSymbols (DynFlags -> Platform
targetPlatform DynFlags
dflags)
    = let dflags' :: DynFlags
dflags' = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_SplitSections
          warn :: [Char]
warn = [Char]
"-fsplit-sections is not useful on this platform " forall a. [a] -> [a] -> [a]
++
                 [Char]
"since it uses subsections-via-symbols. Ignoring."
      in DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' [Char]
warn

   -- Via-C backend only supports unregisterised ABI. Switch to a backend
   -- supporting it if possible.
 | Backend -> Bool
backendUnregisterisedAbiOnly (DynFlags -> Backend
backend DynFlags
dflags) Bool -> Bool -> Bool
&&
   Bool -> Bool
not (Platform -> Bool
platformUnregisterised (DynFlags -> Platform
targetPlatform DynFlags
dflags))
    = let b :: Backend
b = Platform -> Backend
platformDefaultBackend (DynFlags -> Platform
targetPlatform DynFlags
dflags)
      in if Backend -> Bool
backendSwappableWithViaC Backend
b then
           let dflags' :: DynFlags
dflags' = DynFlags
dflags { backend :: Backend
backend = Backend
b }
               warn :: [Char]
warn = [Char]
"Target platform doesn't use unregisterised ABI, so using " forall a. [a] -> [a] -> [a]
++
                      Backend -> [Char]
backendDescription Backend
b forall a. [a] -> [a] -> [a]
++ [Char]
" rather than " forall a. [a] -> [a] -> [a]
++
                      Backend -> [Char]
backendDescription (DynFlags -> Backend
backend DynFlags
dflags)
           in DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' [Char]
warn
         else
           forall a. HasCallStack => [Char] -> a
pgmError (Backend -> [Char]
backendDescription (DynFlags -> Backend
backend DynFlags
dflags) forall a. [a] -> [a] -> [a]
++
                     [Char]
" supports only unregisterised ABI but target platform doesn't use it.")

 | GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_Hpc DynFlags
dflags Bool -> Bool -> Bool
&& Bool -> Bool
not (Backend -> Bool
backendSupportsHpc (DynFlags -> Backend
backend DynFlags
dflags))
    = let dflags' :: DynFlags
dflags' = DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_Hpc
          warn :: [Char]
warn = [Char]
"Hpc can't be used with " forall a. [a] -> [a] -> [a]
++ Backend -> [Char]
backendDescription (DynFlags -> Backend
backend DynFlags
dflags) forall a. [a] -> [a] -> [a]
++
                 [Char]
". Ignoring -fhpc."
      in DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' [Char]
warn

 | Backend -> Bool
backendSwappableWithViaC (DynFlags -> Backend
backend DynFlags
dflags) Bool -> Bool -> Bool
&&
   Platform -> Bool
platformUnregisterised (DynFlags -> Platform
targetPlatform DynFlags
dflags)
    = DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop (DynFlags
dflags { backend :: Backend
backend = Backend
viaCBackend })
           [Char]
"Target platform uses unregisterised ABI, so compiling via C"

 | Backend -> Bool
backendNeedsPlatformNcgSupport (DynFlags -> Backend
backend DynFlags
dflags) Bool -> Bool -> Bool
&&
   Bool -> Bool
not (Platform -> Bool
platformNcgSupported forall a b. (a -> b) -> a -> b
$ DynFlags -> Platform
targetPlatform DynFlags
dflags)
      = let dflags' :: DynFlags
dflags' = DynFlags
dflags { backend :: Backend
backend = Backend
llvmBackend }
            warn :: [Char]
warn = [Char]
"Native code generator doesn't support target platform, so using LLVM"
        in DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' [Char]
warn

 | Bool -> Bool
not (OS -> Bool
osElfTarget OS
os) Bool -> Bool -> Bool
&& GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIE DynFlags
dflags
    = DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_PIE)
           [Char]
"Position-independent only supported on ELF platforms"
 | OS
os forall a. Eq a => a -> a -> Bool
== OS
OSDarwin Bool -> Bool -> Bool
&&
   Arch
arch forall a. Eq a => a -> a -> Bool
== Arch
ArchX86_64 Bool -> Bool -> Bool
&&
   Bool -> Bool
not (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PIC DynFlags
dflags)
    = DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dflags GeneralFlag
Opt_PIC)
           [Char]
"Enabling -fPIC as it is always on for this platform"

 | Backend -> Bool
backendForcesOptimization0 (DynFlags -> Backend
backend DynFlags
dflags)
 , let (DynFlags
dflags', Bool
changed) = Int -> DynFlags -> (DynFlags, Bool)
updOptLevelChanged Int
0 DynFlags
dflags
 , Bool
changed
    = DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags' ([Char]
"Optimization flags are incompatible with the " forall a. [a] -> [a] -> [a]
++
                   Backend -> [Char]
backendDescription (DynFlags -> Backend
backend DynFlags
dflags) forall a. [a] -> [a] -> [a]
++
                                          [Char]
"; optimization flags ignored.")

 | GhcLink
LinkInMemory <- DynFlags -> GhcLink
ghcLink DynFlags
dflags
 , Bool -> Bool
not (GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ExternalInterpreter DynFlags
dflags)
 , Bool
hostIsProfiled
 , Backend -> Bool
backendWritesFiles (DynFlags -> Backend
backend DynFlags
dflags)
 , DynFlags -> Ways
ways DynFlags
dflags Ways -> Way -> Bool
`hasNotWay` Way
WayProf
    = DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
dflags{targetWays_ :: Ways
targetWays_ = Way -> Ways -> Ways
addWay Way
WayProf (DynFlags -> Ways
targetWays_ DynFlags
dflags)}
         [Char]
"Enabling -prof, because -fobject-code is enabled and GHCi is profiled"

 | GhcLink
LinkMergedObj <- DynFlags -> GhcLink
ghcLink DynFlags
dflags
 , Maybe [Char]
Nothing <- DynFlags -> Maybe [Char]
outputFile DynFlags
dflags
 = forall a. HasCallStack => [Char] -> a
pgmError [Char]
"--output must be specified when using --merge-objs"

 | Bool
otherwise = (DynFlags
dflags, [])
    where loc :: SrcSpan
loc = FastString -> SrcSpan
mkGeneralSrcSpan ([Char] -> FastString
fsLit [Char]
"when making flags consistent")
          loop :: DynFlags -> [Char] -> (DynFlags, [Located [Char]])
loop DynFlags
updated_dflags [Char]
warning
              = case DynFlags -> (DynFlags, [Located [Char]])
makeDynFlagsConsistent DynFlags
updated_dflags of
                (DynFlags
dflags', [Located [Char]]
ws) -> (DynFlags
dflags', forall l e. l -> e -> GenLocated l e
L SrcSpan
loc [Char]
warning forall a. a -> [a] -> [a]
: [Located [Char]]
ws)
          platform :: Platform
platform = DynFlags -> Platform
targetPlatform DynFlags
dflags
          arch :: Arch
arch = Platform -> Arch
platformArch Platform
platform
          os :: OS
os   = Platform -> OS
platformOS   Platform
platform


setUnsafeGlobalDynFlags :: DynFlags -> IO ()
setUnsafeGlobalDynFlags :: DynFlags -> IO ()
setUnsafeGlobalDynFlags DynFlags
dflags = do
   forall a. IORef a -> a -> IO ()
writeIORef IORef Bool
v_unsafeHasPprDebug (DynFlags -> Bool
hasPprDebug DynFlags
dflags)
   forall a. IORef a -> a -> IO ()
writeIORef IORef Bool
v_unsafeHasNoDebugOutput (DynFlags -> Bool
hasNoDebugOutput DynFlags
dflags)
   forall a. IORef a -> a -> IO ()
writeIORef IORef Bool
v_unsafeHasNoStateHack (DynFlags -> Bool
hasNoStateHack DynFlags
dflags)


-- -----------------------------------------------------------------------------
-- SSE and AVX

isSse4_2Enabled :: DynFlags -> Bool
isSse4_2Enabled :: DynFlags -> Bool
isSse4_2Enabled DynFlags
dflags = DynFlags -> Maybe SseVersion
sseVersion DynFlags
dflags forall a. Ord a => a -> a -> Bool
>= forall a. a -> Maybe a
Just SseVersion
SSE42

isAvxEnabled :: DynFlags -> Bool
isAvxEnabled :: DynFlags -> Bool
isAvxEnabled DynFlags
dflags = DynFlags -> Bool
avx DynFlags
dflags Bool -> Bool -> Bool
|| DynFlags -> Bool
avx2 DynFlags
dflags Bool -> Bool -> Bool
|| DynFlags -> Bool
avx512f DynFlags
dflags

isAvx2Enabled :: DynFlags -> Bool
isAvx2Enabled :: DynFlags -> Bool
isAvx2Enabled DynFlags
dflags = DynFlags -> Bool
avx2 DynFlags
dflags Bool -> Bool -> Bool
|| DynFlags -> Bool
avx512f DynFlags
dflags

isAvx512cdEnabled :: DynFlags -> Bool
isAvx512cdEnabled :: DynFlags -> Bool
isAvx512cdEnabled DynFlags
dflags = DynFlags -> Bool
avx512cd DynFlags
dflags

isAvx512erEnabled :: DynFlags -> Bool
isAvx512erEnabled :: DynFlags -> Bool
isAvx512erEnabled DynFlags
dflags = DynFlags -> Bool
avx512er DynFlags
dflags

isAvx512fEnabled :: DynFlags -> Bool
isAvx512fEnabled :: DynFlags -> Bool
isAvx512fEnabled DynFlags
dflags = DynFlags -> Bool
avx512f DynFlags
dflags

isAvx512pfEnabled :: DynFlags -> Bool
isAvx512pfEnabled :: DynFlags -> Bool
isAvx512pfEnabled DynFlags
dflags = DynFlags -> Bool
avx512pf DynFlags
dflags

-- -----------------------------------------------------------------------------
-- BMI2

isBmiEnabled :: DynFlags -> Bool
isBmiEnabled :: DynFlags -> Bool
isBmiEnabled DynFlags
dflags = case Platform -> Arch
platformArch (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
    Arch
ArchX86_64 -> DynFlags -> Maybe BmiVersion
bmiVersion DynFlags
dflags forall a. Ord a => a -> a -> Bool
>= forall a. a -> Maybe a
Just BmiVersion
BMI1
    Arch
ArchX86    -> DynFlags -> Maybe BmiVersion
bmiVersion DynFlags
dflags forall a. Ord a => a -> a -> Bool
>= forall a. a -> Maybe a
Just BmiVersion
BMI1
    Arch
_          -> Bool
False

isBmi2Enabled :: DynFlags -> Bool
isBmi2Enabled :: DynFlags -> Bool
isBmi2Enabled DynFlags
dflags = case Platform -> Arch
platformArch (DynFlags -> Platform
targetPlatform DynFlags
dflags) of
    Arch
ArchX86_64 -> DynFlags -> Maybe BmiVersion
bmiVersion DynFlags
dflags forall a. Ord a => a -> a -> Bool
>= forall a. a -> Maybe a
Just BmiVersion
BMI2
    Arch
ArchX86    -> DynFlags -> Maybe BmiVersion
bmiVersion DynFlags
dflags forall a. Ord a => a -> a -> Bool
>= forall a. a -> Maybe a
Just BmiVersion
BMI2
    Arch
_          -> Bool
False

-- | Indicate if cost-centre profiling is enabled
sccProfilingEnabled :: DynFlags -> Bool
sccProfilingEnabled :: DynFlags -> Bool
sccProfilingEnabled DynFlags
dflags = Profile -> Bool
profileIsProfiling (DynFlags -> Profile
targetProfile DynFlags
dflags)

-- | Indicate whether we need to generate source notes
needSourceNotes :: DynFlags -> Bool
needSourceNotes :: DynFlags -> Bool
needSourceNotes DynFlags
dflags = DynFlags -> Int
debugLevel DynFlags
dflags forall a. Ord a => a -> a -> Bool
> Int
0
                       Bool -> Bool -> Bool
|| GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_InfoTableMap DynFlags
dflags

-- -----------------------------------------------------------------------------
-- Linker/compiler information

-- LinkerInfo contains any extra options needed by the system linker.
data LinkerInfo
  = GnuLD    [Option]
  | GnuGold  [Option]
  | LlvmLLD  [Option]
  | DarwinLD [Option]
  | SolarisLD [Option]
  | AixLD    [Option]
  | UnknownLD
  deriving LinkerInfo -> LinkerInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LinkerInfo -> LinkerInfo -> Bool
$c/= :: LinkerInfo -> LinkerInfo -> Bool
== :: LinkerInfo -> LinkerInfo -> Bool
$c== :: LinkerInfo -> LinkerInfo -> Bool
Eq

-- CompilerInfo tells us which C compiler we're using
data CompilerInfo
   = GCC
   | Clang
   | AppleClang
   | AppleClang51
   | Emscripten
   | UnknownCC
   deriving CompilerInfo -> CompilerInfo -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompilerInfo -> CompilerInfo -> Bool
$c/= :: CompilerInfo -> CompilerInfo -> Bool
== :: CompilerInfo -> CompilerInfo -> Bool
$c== :: CompilerInfo -> CompilerInfo -> Bool
Eq


-- | Should we use `-XLinker -rpath` when linking or not?
-- See Note [-fno-use-rpaths]
useXLinkerRPath :: DynFlags -> OS -> Bool
useXLinkerRPath :: DynFlags -> OS -> Bool
useXLinkerRPath DynFlags
_ OS
OSDarwin = Bool
False -- See Note [Dynamic linking on macOS]
useXLinkerRPath DynFlags
dflags OS
_ = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_RPath DynFlags
dflags

{-
Note [-fno-use-rpaths]
~~~~~~~~~~~~~~~~~~~~~~

First read, Note [Dynamic linking on macOS] to understand why on darwin we never
use `-XLinker -rpath`.

The specification of `Opt_RPath` is as follows:

The default case `-fuse-rpaths`:
* On darwin, never use `-Xlinker -rpath -Xlinker`, always inject the rpath
  afterwards, see `runInjectRPaths`. There is no way to use `-Xlinker` on darwin
  as things stand but it wasn't documented in the user guide before this patch how
  `-fuse-rpaths` should behave and the fact it was always disabled on darwin.
* Otherwise, use `-Xlinker -rpath -Xlinker` to set the rpath of the executable,
  this is the normal way you should set the rpath.

The case of `-fno-use-rpaths`
* Never inject anything into the rpath.

When this was first implemented, `Opt_RPath` was disabled on darwin, but
the rpath was still always augmented by `runInjectRPaths`, and there was no way to
stop this. This was problematic because you couldn't build an executable in CI
with a clean rpath.

-}

-- -----------------------------------------------------------------------------
-- RTS hooks

-- Convert sizes like "3.5M" into integers
decodeSize :: String -> Integer
decodeSize :: [Char] -> Integer
decodeSize [Char]
str
  | [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
""      = forall a b. (RealFrac a, Integral b) => a -> b
truncate Rational
n
  | [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
"K" Bool -> Bool -> Bool
|| [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
"k" = forall a b. (RealFrac a, Integral b) => a -> b
truncate (Rational
n forall a. Num a => a -> a -> a
* Rational
1000)
  | [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
"M" Bool -> Bool -> Bool
|| [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
"m" = forall a b. (RealFrac a, Integral b) => a -> b
truncate (Rational
n forall a. Num a => a -> a -> a
* Rational
1000 forall a. Num a => a -> a -> a
* Rational
1000)
  | [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
"G" Bool -> Bool -> Bool
|| [Char]
c forall a. Eq a => a -> a -> Bool
== [Char]
"g" = forall a b. (RealFrac a, Integral b) => a -> b
truncate (Rational
n forall a. Num a => a -> a -> a
* Rational
1000 forall a. Num a => a -> a -> a
* Rational
1000 forall a. Num a => a -> a -> a
* Rational
1000)
  | Bool
otherwise            = forall a. GhcException -> a
throwGhcException ([Char] -> GhcException
CmdLineError ([Char]
"can't decode size: " forall a. [a] -> [a] -> [a]
++ [Char]
str))
  where ([Char]
m, [Char]
c) = forall a. (a -> Bool) -> [a] -> ([a], [a])
span Char -> Bool
pred [Char]
str
        n :: Rational
n      = [Char] -> Rational
readRational [Char]
m
        pred :: Char -> Bool
pred Char
c = Char -> Bool
isDigit Char
c Bool -> Bool -> Bool
|| Char
c forall a. Eq a => a -> a -> Bool
== Char
'.'

foreign import ccall unsafe "ghc_lib_parser_setHeapSize"       setHeapSize       :: Int -> IO ()
foreign import ccall unsafe "ghc_lib_parser_enableTimingStats" enableTimingStats :: IO ()


-- | Initialize the pretty-printing options
initSDocContext :: DynFlags -> PprStyle -> SDocContext
initSDocContext :: DynFlags -> PprStyle -> SDocContext
initSDocContext DynFlags
dflags PprStyle
style = SDC
  { sdocStyle :: PprStyle
sdocStyle                       = PprStyle
style
  , sdocColScheme :: Scheme
sdocColScheme                   = DynFlags -> Scheme
colScheme DynFlags
dflags
  , sdocLastColour :: PprColour
sdocLastColour                  = PprColour
Col.colReset
  , sdocShouldUseColor :: Bool
sdocShouldUseColor              = Bool -> OverridingBool -> Bool
overrideWith (DynFlags -> Bool
canUseColor DynFlags
dflags) (DynFlags -> OverridingBool
useColor DynFlags
dflags)
  , sdocDefaultDepth :: Int
sdocDefaultDepth                = DynFlags -> Int
pprUserLength DynFlags
dflags
  , sdocLineLength :: Int
sdocLineLength                  = DynFlags -> Int
pprCols DynFlags
dflags
  , sdocCanUseUnicode :: Bool
sdocCanUseUnicode               = DynFlags -> Bool
useUnicode DynFlags
dflags
  , sdocHexWordLiterals :: Bool
sdocHexWordLiterals             = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_HexWordLiterals DynFlags
dflags
  , sdocPprDebug :: Bool
sdocPprDebug                    = DumpFlag -> DynFlags -> Bool
dopt DumpFlag
Opt_D_ppr_debug DynFlags
dflags
  , sdocPrintUnicodeSyntax :: Bool
sdocPrintUnicodeSyntax          = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintUnicodeSyntax DynFlags
dflags
  , sdocPrintCaseAsLet :: Bool
sdocPrintCaseAsLet              = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PprCaseAsLet DynFlags
dflags
  , sdocPrintTypecheckerElaboration :: Bool
sdocPrintTypecheckerElaboration = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintTypecheckerElaboration DynFlags
dflags
  , sdocPrintAxiomIncomps :: Bool
sdocPrintAxiomIncomps           = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintAxiomIncomps DynFlags
dflags
  , sdocPrintExplicitKinds :: Bool
sdocPrintExplicitKinds          = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintExplicitKinds DynFlags
dflags
  , sdocPrintExplicitCoercions :: Bool
sdocPrintExplicitCoercions      = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintExplicitCoercions DynFlags
dflags
  , sdocPrintExplicitRuntimeReps :: Bool
sdocPrintExplicitRuntimeReps    = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintExplicitRuntimeReps DynFlags
dflags
  , sdocPrintExplicitForalls :: Bool
sdocPrintExplicitForalls        = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintExplicitForalls DynFlags
dflags
  , sdocPrintPotentialInstances :: Bool
sdocPrintPotentialInstances     = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintPotentialInstances DynFlags
dflags
  , sdocPrintEqualityRelations :: Bool
sdocPrintEqualityRelations      = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintEqualityRelations DynFlags
dflags
  , sdocSuppressTicks :: Bool
sdocSuppressTicks               = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressTicks DynFlags
dflags
  , sdocSuppressTypeSignatures :: Bool
sdocSuppressTypeSignatures      = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressTypeSignatures DynFlags
dflags
  , sdocSuppressTypeApplications :: Bool
sdocSuppressTypeApplications    = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressTypeApplications DynFlags
dflags
  , sdocSuppressIdInfo :: Bool
sdocSuppressIdInfo              = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressIdInfo DynFlags
dflags
  , sdocSuppressCoercions :: Bool
sdocSuppressCoercions           = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressCoercions DynFlags
dflags
  , sdocSuppressCoercionTypes :: Bool
sdocSuppressCoercionTypes       = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressCoercionTypes DynFlags
dflags
  , sdocSuppressUnfoldings :: Bool
sdocSuppressUnfoldings          = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressUnfoldings DynFlags
dflags
  , sdocSuppressVarKinds :: Bool
sdocSuppressVarKinds            = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressVarKinds DynFlags
dflags
  , sdocSuppressUniques :: Bool
sdocSuppressUniques             = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressUniques DynFlags
dflags
  , sdocSuppressModulePrefixes :: Bool
sdocSuppressModulePrefixes      = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressModulePrefixes DynFlags
dflags
  , sdocSuppressStgExts :: Bool
sdocSuppressStgExts             = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressStgExts DynFlags
dflags
  , sdocSuppressStgReps :: Bool
sdocSuppressStgReps             = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_SuppressStgReps DynFlags
dflags
  , sdocErrorSpans :: Bool
sdocErrorSpans                  = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_ErrorSpans DynFlags
dflags
  , sdocStarIsType :: Bool
sdocStarIsType                  = Extension -> DynFlags -> Bool
xopt Extension
LangExt.StarIsType DynFlags
dflags
  , sdocLinearTypes :: Bool
sdocLinearTypes                 = Extension -> DynFlags -> Bool
xopt Extension
LangExt.LinearTypes DynFlags
dflags
  , sdocListTuplePuns :: Bool
sdocListTuplePuns               = Bool
True
  , sdocPrintTypeAbbreviations :: Bool
sdocPrintTypeAbbreviations      = Bool
True
  , sdocUnitIdForUser :: FastString -> SDoc
sdocUnitIdForUser               = forall doc. IsLine doc => FastString -> doc
ftext
  }

-- | Initialize the pretty-printing options using the default user style
initDefaultSDocContext :: DynFlags -> SDocContext
initDefaultSDocContext :: DynFlags -> SDocContext
initDefaultSDocContext DynFlags
dflags = DynFlags -> PprStyle -> SDocContext
initSDocContext DynFlags
dflags PprStyle
defaultUserStyle

initPromotionTickContext :: DynFlags -> PromotionTickContext
initPromotionTickContext :: DynFlags -> PromotionTickContext
initPromotionTickContext DynFlags
dflags =
  PromTickCtx {
    ptcListTuplePuns :: Bool
ptcListTuplePuns = Bool
True,
    ptcPrintRedundantPromTicks :: Bool
ptcPrintRedundantPromTicks = GeneralFlag -> DynFlags -> Bool
gopt GeneralFlag
Opt_PrintRedundantPromotionTicks DynFlags
dflags
  }

outputFile :: DynFlags -> Maybe String
outputFile :: DynFlags -> Maybe [Char]
outputFile DynFlags
dflags
   | DynFlags -> Bool
dynamicNow DynFlags
dflags = DynFlags -> Maybe [Char]
dynOutputFile_ DynFlags
dflags
   | Bool
otherwise         = DynFlags -> Maybe [Char]
outputFile_    DynFlags
dflags

objectSuf :: DynFlags -> String
objectSuf :: DynFlags -> [Char]
objectSuf DynFlags
dflags
   | DynFlags -> Bool
dynamicNow DynFlags
dflags = DynFlags -> [Char]
dynObjectSuf_ DynFlags
dflags
   | Bool
otherwise         = DynFlags -> [Char]
objectSuf_    DynFlags
dflags

ways :: DynFlags -> Ways
ways :: DynFlags -> Ways
ways DynFlags
dflags
   | DynFlags -> Bool
dynamicNow DynFlags
dflags = Way -> Ways -> Ways
addWay Way
WayDyn (DynFlags -> Ways
targetWays_ DynFlags
dflags)
   | Bool
otherwise         = DynFlags -> Ways
targetWays_ DynFlags
dflags

-- | Pretty-print the difference between 2 DynFlags.
--
-- For now only their general flags but it could be extended.
-- Useful mostly for debugging.
pprDynFlagsDiff :: DynFlags -> DynFlags -> SDoc
pprDynFlagsDiff :: DynFlags -> DynFlags -> SDoc
pprDynFlagsDiff DynFlags
d1 DynFlags
d2 =
   let gf_removed :: EnumSet GeneralFlag
gf_removed  = forall a. EnumSet a -> EnumSet a -> EnumSet a
EnumSet.difference (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
d1) (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
d2)
       gf_added :: EnumSet GeneralFlag
gf_added    = forall a. EnumSet a -> EnumSet a -> EnumSet a
EnumSet.difference (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
d2) (DynFlags -> EnumSet GeneralFlag
generalFlags DynFlags
d1)
       ext_removed :: EnumSet Extension
ext_removed = forall a. EnumSet a -> EnumSet a -> EnumSet a
EnumSet.difference (DynFlags -> EnumSet Extension
extensionFlags DynFlags
d1) (DynFlags -> EnumSet Extension
extensionFlags DynFlags
d2)
       ext_added :: EnumSet Extension
ext_added   = forall a. EnumSet a -> EnumSet a -> EnumSet a
EnumSet.difference (DynFlags -> EnumSet Extension
extensionFlags DynFlags
d2) (DynFlags -> EnumSet Extension
extensionFlags DynFlags
d1)
   in forall doc. IsDoc doc => [doc] -> doc
vcat
      [ forall doc. IsLine doc => [Char] -> doc
text [Char]
"Added general flags:"
      , forall doc. IsLine doc => [Char] -> doc
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ forall a. Enum a => EnumSet a -> [a]
EnumSet.toList forall a b. (a -> b) -> a -> b
$ EnumSet GeneralFlag
gf_added
      , forall doc. IsLine doc => [Char] -> doc
text [Char]
"Removed general flags:"
      , forall doc. IsLine doc => [Char] -> doc
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ forall a. Enum a => EnumSet a -> [a]
EnumSet.toList forall a b. (a -> b) -> a -> b
$ EnumSet GeneralFlag
gf_removed
      , forall doc. IsLine doc => [Char] -> doc
text [Char]
"Added extension flags:"
      , forall doc. IsLine doc => [Char] -> doc
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ forall a. Enum a => EnumSet a -> [a]
EnumSet.toList forall a b. (a -> b) -> a -> b
$ EnumSet Extension
ext_added
      , forall doc. IsLine doc => [Char] -> doc
text [Char]
"Removed extension flags:"
      , forall doc. IsLine doc => [Char] -> doc
text forall a b. (a -> b) -> a -> b
$ forall a. Show a => a -> [Char]
show forall a b. (a -> b) -> a -> b
$ forall a. Enum a => EnumSet a -> [a]
EnumSet.toList forall a b. (a -> b) -> a -> b
$ EnumSet Extension
ext_removed
      ]

updatePlatformConstants :: DynFlags -> Maybe PlatformConstants -> IO DynFlags
updatePlatformConstants :: DynFlags -> Maybe PlatformConstants -> IO DynFlags
updatePlatformConstants DynFlags
dflags Maybe PlatformConstants
mconstants = do
  let platform1 :: Platform
platform1 = (DynFlags -> Platform
targetPlatform DynFlags
dflags) { platform_constants :: Maybe PlatformConstants
platform_constants = Maybe PlatformConstants
mconstants }
  let dflags1 :: DynFlags
dflags1   = DynFlags
dflags { targetPlatform :: Platform
targetPlatform = Platform
platform1 }
  forall (m :: * -> *) a. Monad m => a -> m a
return DynFlags
dflags1