{-# 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,
        wopt_set_all_custom, wopt_unset_all_custom,
        wopt_set_all_fatal_custom, wopt_unset_all_fatal_custom,
        wopt_set_custom, wopt_unset_custom,
        wopt_set_fatal_custom, wopt_unset_fatal_custom,
        wopt_any_custom,
        xopt, xopt_set, xopt_unset,
        xopt_set_unlessExplSpec,
        xopt_DuplicateRecordFields,
        xopt_FieldSelectors,
        lang_set,
        DynamicTooState(..), dynamicTooState, setDynamicNow,
        sccProfilingEnabled,
        needSourceNotes,
        OnOff(..),
        DynFlags(..),
        ParMakeCount(..),
        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,
        codeGenFlags,
        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_cpp,
        sPgm_a,
        sPgm_l,
        sPgm_lm,
        sPgm_windres,
        sPgm_ar,
        sPgm_ranlib,
        sPgm_lo,
        sPgm_lc,
        sPgm_las,
        sPgm_i,
        sOpt_L,
        sOpt_P,
        sOpt_P_fingerprint,
        sOpt_JSP,
        sOpt_JSP_fingerprint,
        sOpt_CmmP,
        sOpt_CmmP_fingerprint,
        sOpt_F,
        sOpt_c,
        sOpt_cxx,
        sOpt_a,
        sOpt_l,
        sOpt_lm,
        sOpt_windres,
        sOpt_lo,
        sOpt_lc,
        sOpt_i,
        sExtraGccViaCFlags,
        sTargetPlatformString,
        sGhcWithInterpreter,
        sLibFFI,
        GhcNameVersion(..),
        FileSettings(..),
        PlatformMisc(..),
        settings,
        programName, projectVersion,
        ghcUsagePath, ghciUsagePath, topDir,
        versionedAppDir, versionedFilePath,
        extraGccViaCFlags, globalPackageDatabasePath,
        pgm_L, pgm_P, pgm_JSP, pgm_CmmP, pgm_F, pgm_c, pgm_cxx, pgm_cpp, pgm_a, pgm_l,
        pgm_lm, pgm_windres, pgm_ar,
        pgm_ranlib, pgm_lo, pgm_lc, pgm_las, pgm_i,
        opt_L, opt_P, opt_JSP, opt_CmmP, opt_F, opt_c, opt_cxx, opt_a, opt_l, opt_lm, opt_i,
        opt_P_signature, opt_JSP_signature, opt_CmmP_signature,
        opt_windres, opt_lo, opt_lc, opt_las,
        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,
        flagSuggestions,

        -- ** 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,
        isFmaEnabled,

        -- * Linker/compiler information
        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.Unit.Types
import GHC.Unit.Parser
import GHC.Unit.Module
import GHC.Unit.Module.Warnings
import GHC.Driver.DynFlags
import GHC.Driver.Config.Diagnostic
import GHC.Driver.Flags
import GHC.Driver.Backend
import GHC.Driver.Errors.Types
import GHC.Driver.Plugins.External
import GHC.Settings.Config
import GHC.Core.Unfold
import GHC.Driver.CmdLine
import GHC.Utils.Panic
import GHC.Utils.Misc
import GHC.Utils.Constants (debugIsOn)
import GHC.Utils.GlobalVars
import GHC.Data.Maybe
import GHC.Data.Bool
import GHC.Data.StringBuffer (stringToStringBuffer)
import GHC.Types.Error
import GHC.Types.Name.Reader (RdrName(..))
import GHC.Types.Name.Occurrence (isVarOcc, occNameString)
import GHC.Utils.Monad
import GHC.Types.SrcLoc
import GHC.Types.SafeHaskell
import GHC.Types.Basic ( treatZeroAsInf )
import GHC.Data.FastString
import GHC.Utils.TmpFs
import GHC.Utils.Fingerprint
import GHC.Utils.Outputable
import GHC.Utils.Error (emptyDiagOpts)
import GHC.Settings
import GHC.CmmToAsm.CFG.Weight
import GHC.Core.Opt.CallerCC
import GHC.Parser (parseIdentifier)
import GHC.Parser.Lexer (mkParserOpts, initParserState, P(..), ParseResult(..))

import GHC.SysTools.BaseDir ( expandToolDir, expandTopDir )

import Data.IORef
import Control.Arrow ((&&&))
import Control.Monad
import Control.Monad.Trans.State as State
import Data.Functor.Identity

import Data.Ord
import Data.Char
import Data.List (intercalate, sortBy, partition)
import qualified Data.List.NonEmpty as NE
import qualified Data.Map as Map
import qualified Data.Set as Set
import Data.Word
import System.FilePath
import Text.ParserCombinators.ReadP hiding (char)
import Text.ParserCombinators.ReadP as R

import qualified GHC.Data.EnumSet as EnumSet

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

{- 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.
-}

-----------------------------------------------------------------------------
-- 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
  }

pgm_L                 :: DynFlags -> String
pgm_L :: DynFlags -> [Char]
pgm_L DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_L (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_P                 :: DynFlags -> (String,[Option])
pgm_P :: DynFlags -> ([Char], [Option])
pgm_P DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_P (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_JSP               :: DynFlags -> (String,[Option])
pgm_JSP :: DynFlags -> ([Char], [Option])
pgm_JSP DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_JSP (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_CmmP              :: DynFlags -> (String,[Option])
pgm_CmmP :: DynFlags -> ([Char], [Option])
pgm_CmmP DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_CmmP (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_F                 :: DynFlags -> String
pgm_F :: DynFlags -> [Char]
pgm_F DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_F (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_c                 :: DynFlags -> String
pgm_c :: DynFlags -> [Char]
pgm_c DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_c (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_cxx               :: DynFlags -> String
pgm_cxx :: DynFlags -> [Char]
pgm_cxx DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_cxx (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_cpp               :: DynFlags -> (String,[Option])
pgm_cpp :: DynFlags -> ([Char], [Option])
pgm_cpp DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_cpp (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_a                 :: DynFlags -> (String,[Option])
pgm_a :: DynFlags -> ([Char], [Option])
pgm_a DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_a (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_l                 :: DynFlags -> (String,[Option])
pgm_l :: DynFlags -> ([Char], [Option])
pgm_l DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_l (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lm                 :: DynFlags -> Maybe (String,[Option])
pgm_lm :: DynFlags -> Maybe ([Char], [Option])
pgm_lm DynFlags
dflags = ToolSettings -> Maybe ([Char], [Option])
toolSettings_pgm_lm (ToolSettings -> Maybe ([Char], [Option]))
-> ToolSettings -> Maybe ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_windres           :: DynFlags -> String
pgm_windres :: DynFlags -> [Char]
pgm_windres DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_windres (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_ar                :: DynFlags -> String
pgm_ar :: DynFlags -> [Char]
pgm_ar DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_ar (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_ranlib            :: DynFlags -> String
pgm_ranlib :: DynFlags -> [Char]
pgm_ranlib DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_ranlib (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lo                :: DynFlags -> (String,[Option])
pgm_lo :: DynFlags -> ([Char], [Option])
pgm_lo DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_lo (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_lc                :: DynFlags -> (String,[Option])
pgm_lc :: DynFlags -> ([Char], [Option])
pgm_lc DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_lc (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_las               :: DynFlags -> (String,[Option])
pgm_las :: DynFlags -> ([Char], [Option])
pgm_las DynFlags
dflags = ToolSettings -> ([Char], [Option])
toolSettings_pgm_las (ToolSettings -> ([Char], [Option]))
-> ToolSettings -> ([Char], [Option])
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
pgm_i                 :: DynFlags -> String
pgm_i :: DynFlags -> [Char]
pgm_i DynFlags
dflags = ToolSettings -> [Char]
toolSettings_pgm_i (ToolSettings -> [Char]) -> ToolSettings -> [Char]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_L                 :: DynFlags -> [String]
opt_L :: DynFlags -> [[Char]]
opt_L DynFlags
dflags = ToolSettings -> [[Char]]
toolSettings_opt_L (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_P                 :: DynFlags -> [String]
opt_P :: DynFlags -> [[Char]]
opt_P DynFlags
dflags = (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
            [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_P (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_JSP               :: DynFlags -> [String]
opt_JSP :: DynFlags -> [[Char]]
opt_JSP DynFlags
dflags = (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
            [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_JSP (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_CmmP              :: DynFlags -> [String]
opt_CmmP :: DynFlags -> [[Char]]
opt_CmmP DynFlags
dflags = ToolSettings -> [[Char]]
toolSettings_opt_CmmP (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ 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 =
  ( (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
  , ToolSettings -> Fingerprint
toolSettings_opt_P_fingerprint (ToolSettings -> Fingerprint) -> ToolSettings -> Fingerprint
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
  )
-- This function packages everything that's needed to fingerprint opt_P
-- flags. See Note [Repeated -optP hashing].
opt_JSP_signature     :: DynFlags -> ([String], Fingerprint)
opt_JSP_signature :: DynFlags -> ([[Char]], Fingerprint)
opt_JSP_signature DynFlags
dflags =
  ( (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptP (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
  , ToolSettings -> Fingerprint
toolSettings_opt_JSP_fingerprint (ToolSettings -> Fingerprint) -> ToolSettings -> Fingerprint
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
  )
-- This function packages everything that's needed to fingerprint opt_CmmP
-- flags. See Note [Repeated -optP hashing].
opt_CmmP_signature     :: DynFlags -> Fingerprint
opt_CmmP_signature :: DynFlags -> Fingerprint
opt_CmmP_signature = ToolSettings -> Fingerprint
toolSettings_opt_CmmP_fingerprint (ToolSettings -> Fingerprint)
-> (DynFlags -> ToolSettings) -> DynFlags -> Fingerprint
forall b c a. (b -> c) -> (a -> b) -> a -> c
. DynFlags -> ToolSettings
toolSettings

opt_F                 :: DynFlags -> [String]
opt_F :: DynFlags -> [[Char]]
opt_F DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_F (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_c                 :: DynFlags -> [String]
opt_c :: DynFlags -> [[Char]]
opt_c DynFlags
dflags = (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptc (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
            [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_c (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_cxx               :: DynFlags -> [String]
opt_cxx :: DynFlags -> [[Char]]
opt_cxx DynFlags
dflags = (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptcxx (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
           [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_cxx (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_a                 :: DynFlags -> [String]
opt_a :: DynFlags -> [[Char]]
opt_a DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_a (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_l                 :: DynFlags -> [String]
opt_l :: DynFlags -> [[Char]]
opt_l DynFlags
dflags = (Way -> [[Char]]) -> Set Way -> [[Char]]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap (Platform -> Way -> [[Char]]
wayOptl (DynFlags -> Platform
targetPlatform DynFlags
dflags)) (DynFlags -> Set Way
ways DynFlags
dflags)
            [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ToolSettings -> [[Char]]
toolSettings_opt_l (DynFlags -> ToolSettings
toolSettings DynFlags
dflags)
opt_lm                :: DynFlags -> [String]
opt_lm :: DynFlags -> [[Char]]
opt_lm DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lm (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_windres           :: DynFlags -> [String]
opt_windres :: DynFlags -> [[Char]]
opt_windres DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_windres (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_lo                :: DynFlags -> [String]
opt_lo :: DynFlags -> [[Char]]
opt_lo DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lo (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_lc                :: DynFlags -> [String]
opt_lc :: DynFlags -> [[Char]]
opt_lc DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_lc (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_las               :: DynFlags -> [String]
opt_las :: DynFlags -> [[Char]]
opt_las DynFlags
dflags = ToolSettings -> [[Char]]
toolSettings_opt_las (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags
opt_i                 :: DynFlags -> [String]
opt_i :: DynFlags -> [[Char]]
opt_i DynFlags
dflags= ToolSettings -> [[Char]]
toolSettings_opt_i (ToolSettings -> [[Char]]) -> ToolSettings -> [[Char]]
forall a b. (a -> b) -> a -> b
$ DynFlags -> ToolSettings
toolSettings DynFlags
dflags

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

{-
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"
-}

-- | 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` Language -> Maybe Language
forall a. a -> Maybe a
Just Language
l)

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

-- | Is Safe Haskell on in some way (including inference mode)
safeHaskellOn :: DynFlags -> Bool
safeHaskellOn :: DynFlags -> TurnOnFlag
safeHaskellOn DynFlags
dflags = DynFlags -> TurnOnFlag
safeHaskellModeEnabled DynFlags
dflags TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| DynFlags -> TurnOnFlag
safeInferOn DynFlags
dflags

safeHaskellModeEnabled :: DynFlags -> Bool
safeHaskellModeEnabled :: DynFlags -> TurnOnFlag
safeHaskellModeEnabled DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> [SafeHaskellMode] -> TurnOnFlag
forall a. Eq a => a -> [a] -> TurnOnFlag
forall (t :: * -> *) a.
(Foldable t, Eq a) =>
a -> t a -> TurnOnFlag
`elem` [SafeHaskellMode
Sf_Unsafe, SafeHaskellMode
Sf_Trustworthy
                                                   , SafeHaskellMode
Sf_Safe ]


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

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

-- | Test if Safe Imports are on in some form
safeImportsOn :: DynFlags -> Bool
safeImportsOn :: DynFlags -> TurnOnFlag
safeImportsOn DynFlags
dflags = DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
Sf_Unsafe TurnOnFlag -> TurnOnFlag -> TurnOnFlag
||
                       DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
Sf_Trustworthy TurnOnFlag -> TurnOnFlag -> TurnOnFlag
||
                       DynFlags -> SafeHaskellMode
safeHaskell DynFlags
dflags SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== 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
              safeM <- SafeHaskellMode -> SafeHaskellMode -> DynP SafeHaskellMode
combineSafeFlags SafeHaskellMode
sf SafeHaskellMode
s
              case s of
                SafeHaskellMode
Sf_Safe -> DynFlags -> DynP DynFlags
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell = safeM, safeInfer = False }
                -- leave safe inference on in Trustworthy mode so we can warn
                -- if it could have been inferred safe.
                SafeHaskellMode
Sf_Trustworthy -> do
                  l <- EwM (CmdLineP DynFlags) SrcSpan
forall (m :: * -> *). Monad m => EwM m SrcSpan
getCurLoc
                  return $ dfs { safeHaskell = safeM, trustworthyOnLoc = l }
                -- leave safe inference on in Unsafe mode as well.
                SafeHaskellMode
_ -> DynFlags -> DynP DynFlags
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ DynFlags
dfs { safeHaskell = 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 -> TurnOnFlag
safeDirectImpsReq DynFlags
d = DynFlags -> TurnOnFlag
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 -> TurnOnFlag
safeImplicitImpsReq DynFlags
d = DynFlags -> TurnOnFlag
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 SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
Sf_None         = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
b
                     | SafeHaskellMode
b SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
Sf_None         = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
a
                     | SafeHaskellMode
a SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
Sf_Ignore TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| SafeHaskellMode
b SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
Sf_Ignore = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
Sf_Ignore
                     | SafeHaskellMode
a SafeHaskellMode -> SafeHaskellMode -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== SafeHaskellMode
b               = SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (m :: * -> *) a. Monad m => a -> m a
return SafeHaskellMode
a
                     | TurnOnFlag
otherwise            = [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addErr [Char]
errm DynP () -> DynP SafeHaskellMode -> DynP SafeHaskellMode
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SafeHaskellMode -> DynP SafeHaskellMode
forall a. a -> EwM (CmdLineP DynFlags) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure SafeHaskellMode
a
    where errm :: [Char]
errm = [Char]
"Incompatible Safe Haskell flags! ("
                    [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ SafeHaskellMode -> [Char]
forall a. Show a => a -> [Char]
show SafeHaskellMode
a [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
", " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ SafeHaskellMode -> [Char]
forall a. Show a => a -> [Char]
show SafeHaskellMode
b [Char] -> [Char] -> [Char]
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
  :: [(LangExt.Extension, DynFlags -> SrcSpan, DynFlags -> Bool, DynFlags -> DynFlags)]
unsafeFlags :: [(Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
  DynFlags -> DynFlags)]
unsafeFlags = [ (Extension
LangExt.GeneralizedNewtypeDeriving, DynFlags -> SrcSpan
newDerivOnLoc,
                    Extension -> DynFlags -> TurnOnFlag
xopt Extension
LangExt.GeneralizedNewtypeDeriving,
                    (DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.GeneralizedNewtypeDeriving)
              , (Extension
LangExt.DerivingVia, DynFlags -> SrcSpan
deriveViaOnLoc,
                    Extension -> DynFlags -> TurnOnFlag
xopt Extension
LangExt.DerivingVia,
                    (DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.DerivingVia)
              , (Extension
LangExt.TemplateHaskell, DynFlags -> SrcSpan
thOnLoc,
                    Extension -> DynFlags -> TurnOnFlag
xopt Extension
LangExt.TemplateHaskell,
                    (DynFlags -> Extension -> DynFlags)
-> Extension -> DynFlags -> DynFlags
forall a b c. (a -> b -> c) -> b -> a -> c
flip DynFlags -> Extension -> DynFlags
xopt_unset Extension
LangExt.TemplateHaskell)
              ]
unsafeFlagsForInfer :: [(Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
  DynFlags -> DynFlags)]
unsafeFlagsForInfer = [(Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
  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 = [a] -> [a]
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 Int -> Int -> TurnOnFlag
forall a. Ord a => a -> a -> TurnOnFlag
>= Int
4 = [[Char]
"-v"]
  | TurnOnFlag
otherwise             = []

setObjectDir, setHiDir, setHieDir, setStubDir, setDumpDir, setOutputDir,
         setDynObjectSuf, setDynHiSuf,
         setDylibInstallName,
         setObjectSuf, setHiSuf, setHieSuf, setHcSuf, parseDynLibLoaderMode,
         setPgmP, setPgmJSP, setPgmCmmP, addOptl, addOptc, addOptcxx, addOptP,
         addOptJSP, addOptCmmP,
         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  = Just f}
setHiDir :: [Char] -> DynFlags -> DynFlags
setHiDir      [Char]
f DynFlags
d = DynFlags
d { hiDir      = Just f}
setHieDir :: [Char] -> DynFlags -> DynFlags
setHieDir     [Char]
f DynFlags
d = DynFlags
d { hieDir     = Just f}
setStubDir :: [Char] -> DynFlags -> DynFlags
setStubDir    [Char]
f DynFlags
d = DynFlags
d { stubDir    = Just f
                      , includePaths = addGlobalInclude (includePaths d) [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    = Just f}
setOutputDir :: [Char] -> DynFlags -> DynFlags
setOutputDir  [Char]
f = [Char] -> DynFlags -> DynFlags
setObjectDir [Char]
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setHieDir [Char]
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setHiDir [Char]
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setStubDir [Char]
f
                (DynFlags -> DynFlags)
-> (DynFlags -> DynFlags) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> DynFlags -> DynFlags
setDumpDir [Char]
f
setDylibInstallName :: [Char] -> DynFlags -> DynFlags
setDylibInstallName  [Char]
f DynFlags
d = DynFlags
d { dylibInstallName = Just f}

setObjectSuf :: [Char] -> DynFlags -> DynFlags
setObjectSuf    [Char]
f DynFlags
d = DynFlags
d { objectSuf_    = f}
setDynObjectSuf :: [Char] -> DynFlags -> DynFlags
setDynObjectSuf [Char]
f DynFlags
d = DynFlags
d { dynObjectSuf_ = f}
setHiSuf :: [Char] -> DynFlags -> DynFlags
setHiSuf        [Char]
f DynFlags
d = DynFlags
d { hiSuf_        = f}
setHieSuf :: [Char] -> DynFlags -> DynFlags
setHieSuf       [Char]
f DynFlags
d = DynFlags
d { hieSuf        = f}
setDynHiSuf :: [Char] -> DynFlags -> DynFlags
setDynHiSuf     [Char]
f DynFlags
d = DynFlags
d { dynHiSuf_     = f}
setHcSuf :: [Char] -> DynFlags -> DynFlags
setHcSuf        [Char]
f DynFlags
d = DynFlags
d { hcSuf         = f}

setOutputFile :: Maybe [Char] -> DynFlags -> DynFlags
setOutputFile    Maybe [Char]
f DynFlags
d = DynFlags
d { outputFile_    = f}
setDynOutputFile :: Maybe [Char] -> DynFlags -> DynFlags
setDynOutputFile Maybe [Char]
f DynFlags
d = DynFlags
d { dynOutputFile_ = f}
setOutputHi :: Maybe [Char] -> DynFlags -> DynFlags
setOutputHi      Maybe [Char]
f DynFlags
d = DynFlags
d { outputHi       = f}
setDynOutputHi :: Maybe [Char] -> DynFlags -> DynFlags
setDynOutputHi   Maybe [Char]
f DynFlags
d = DynFlags
d { dynOutputHi    = f}

parseUnitInsts :: String -> Instantiations
parseUnitInsts :: [Char] -> Instantiations
parseUnitInsts [Char]
str = case ((Instantiations, [Char]) -> TurnOnFlag)
-> [(Instantiations, [Char])] -> [(Instantiations, [Char])]
forall a. (a -> TurnOnFlag) -> [a] -> [a]
filter (([Char] -> [Char] -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
==[Char]
"")([Char] -> TurnOnFlag)
-> ((Instantiations, [Char]) -> [Char])
-> (Instantiations, [Char])
-> TurnOnFlag
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(Instantiations, [Char]) -> [Char]
forall a b. (a, b) -> b
snd) (ReadP Instantiations -> ReadS Instantiations
forall a. ReadP a -> ReadS a
readP_to_S ReadP Instantiations
parse [Char]
str) of
    [(Instantiations
r, [Char]
"")] -> Instantiations
r
    [(Instantiations, [Char])]
_ -> GhcException -> Instantiations
forall a. GhcException -> a
throwGhcException (GhcException -> Instantiations) -> GhcException -> Instantiations
forall a b. (a -> b) -> a -> b
$ [Char] -> GhcException
CmdLineError ([Char]
"Can't parse -instantiated-with: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
str)
  where parse :: ReadP Instantiations
parse = ReadP (ModuleName, Module) -> ReadP Char -> ReadP Instantiations
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
            n <- ReadP ModuleName
parseModuleName
            _ <- R.char '='
            m <- parseHoleyModule
            return (n, m)

setUnitInstantiations :: String -> DynFlags -> DynFlags
setUnitInstantiations :: [Char] -> DynFlags -> DynFlags
setUnitInstantiations [Char]
s DynFlags
d =
    DynFlags
d { homeUnitInstantiations_ = parseUnitInsts s }

setUnitInstanceOf :: String -> DynFlags -> DynFlags
setUnitInstanceOf :: [Char] -> DynFlags -> DynFlags
setUnitInstanceOf [Char]
s DynFlags
d =
    DynFlags
d { homeUnitInstanceOf_ = Just (UnitId (fsLit s)) }

addPluginModuleName :: String -> DynFlags -> DynFlags
addPluginModuleName :: [Char] -> DynFlags -> DynFlags
addPluginModuleName [Char]
name DynFlags
d = DynFlags
d { pluginModNames = (mkModuleName name) : (pluginModNames d) }

clearPluginModuleNames :: DynFlags -> DynFlags
clearPluginModuleNames :: DynFlags -> DynFlags
clearPluginModuleNames DynFlags
d =
    DynFlags
d { pluginModNames = []
      , pluginModNameOpts = []
      }

addPluginModuleNameOption :: String -> DynFlags -> DynFlags
addPluginModuleNameOption :: [Char] -> DynFlags -> DynFlags
addPluginModuleNameOption [Char]
optflag DynFlags
d = DynFlags
d { pluginModNameOpts = (mkModuleName m, option) : (pluginModNameOpts d) }
  where ([Char]
m, [Char]
rest) = (Char -> TurnOnFlag) -> [Char] -> ([Char], [Char])
forall a. (a -> TurnOnFlag) -> [a] -> ([a], [a])
break (Char -> Char -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== 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 = r : externalPluginSpecs d }
  Maybe ExternalPluginSpec
Nothing -> [Char] -> DynFlags
forall a. [Char] -> a
cmdLineError ([Char] -> DynFlags) -> [Char] -> DynFlags
forall a b. (a -> b) -> a -> b
$ [Char]
"Couldn't parse external plugin specification: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
optflag

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

parseDynLibLoaderMode :: [Char] -> DynFlags -> DynFlags
parseDynLibLoaderMode [Char]
f DynFlags
d =
 case Int -> [Char] -> ([Char], [Char])
forall a. Int -> [a] -> ([a], [a])
splitAt Int
8 [Char]
f of
   ([Char]
"deploy", [Char]
"")       -> DynFlags
d { dynLibLoader = Deployable }
   ([Char]
"sysdep", [Char]
"")       -> DynFlags
d { dynLibLoader = SystemDependent }
   ([Char], [Char])
_                    -> GhcException -> DynFlags
forall a. GhcException -> a
throwGhcException ([Char] -> GhcException
CmdLineError ([Char]
"Unknown dynlib loader: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
f))

setDumpPrefixForce :: Maybe [Char] -> DynFlags -> DynFlags
setDumpPrefixForce Maybe [Char]
f DynFlags
d = DynFlags
d { dumpPrefixForce = 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   = (pgm, map Option args)})
  where ([Char]
pgm:[[Char]]
args) = [Char] -> [[Char]]
words [Char]
f
-- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
-- Config.hs should really use Option.
setPgmJSP :: [Char] -> DynFlags -> DynFlags
setPgmJSP   [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_pgm_JSP   = (pgm, map Option args)})
  where ([Char]
pgm:[[Char]]
args) = [Char] -> [[Char]]
words [Char]
f
-- XXX HACK: Prelude> words "'does not' work" ===> ["'does","not'","work"]
-- Config.hs should really use Option.
setPgmCmmP :: [Char] -> DynFlags -> DynFlags
setPgmCmmP [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_pgm_CmmP = (pgm, map Option 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   = f : toolSettings_opt_l s})
addOptc :: [Char] -> DynFlags -> DynFlags
addOptc   [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_c   = f : toolSettings_opt_c s})
addOptcxx :: [Char] -> DynFlags -> DynFlags
addOptcxx [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_opt_cxx = f : toolSettings_opt_cxx s})
addOptP :: [Char] -> DynFlags -> DynFlags
addOptP   [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
          { toolSettings_opt_P   = f : toolSettings_opt_P s
          , toolSettings_opt_P_fingerprint = fingerprintStrings (f : toolSettings_opt_P s)
          }
          -- See Note [Repeated -optP hashing]
addOptJSP :: [Char] -> DynFlags -> DynFlags
addOptJSP [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
          { toolSettings_opt_JSP   = f : toolSettings_opt_JSP s
          , toolSettings_opt_JSP_fingerprint = fingerprintStrings (f : toolSettings_opt_JSP s)
          }
          -- See Note [Repeated -optP hashing]
addOptCmmP :: [Char] -> DynFlags -> DynFlags
addOptCmmP [Char]
f = (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
          { toolSettings_opt_CmmP = f : toolSettings_opt_CmmP s
          , toolSettings_opt_CmmP_fingerprint = fingerprintStrings (f : toolSettings_opt_CmmP s)
          }

setDepMakefile :: FilePath -> DynFlags -> DynFlags
setDepMakefile :: [Char] -> DynFlags -> DynFlags
setDepMakefile [Char]
f DynFlags
d = DynFlags
d { depMakefile = f }

setDepIncludeCppDeps :: Bool -> DynFlags -> DynFlags
setDepIncludeCppDeps :: TurnOnFlag -> DynFlags -> DynFlags
setDepIncludeCppDeps TurnOnFlag
b DynFlags
d = DynFlags
d { depIncludeCppDeps = b }

setDepIncludePkgDeps :: Bool -> DynFlags -> DynFlags
setDepIncludePkgDeps :: TurnOnFlag -> DynFlags -> DynFlags
setDepIncludePkgDeps TurnOnFlag
b DynFlags
d = DynFlags
d { depIncludePkgDeps = b }

addDepExcludeMod :: String -> DynFlags -> DynFlags
addDepExcludeMod :: [Char] -> DynFlags -> DynFlags
addDepExcludeMod [Char]
m DynFlags
d
    = DynFlags
d { depExcludeMods = mkModuleName m : depExcludeMods d }

addDepSuffix :: FilePath -> DynFlags -> DynFlags
addDepSuffix :: [Char] -> DynFlags -> DynFlags
addDepSuffix [Char]
s DynFlags
d = DynFlags
d { depSuffixes = s : depSuffixes d }

addCmdlineFramework :: [Char] -> DynFlags -> DynFlags
addCmdlineFramework [Char]
f DynFlags
d = DynFlags
d { cmdlineFrameworks = f : cmdlineFrameworks d}

addGhcVersionFile :: FilePath -> DynFlags -> DynFlags
addGhcVersionFile :: [Char] -> DynFlags -> DynFlags
addGhcVersionFile [Char]
f DynFlags
d = DynFlags
d { ghcVersionFile = Just f }

addHaddockOpts :: [Char] -> DynFlags -> DynFlags
addHaddockOpts [Char]
f DynFlags
d = DynFlags
d { haddockOptions = Just f}

addGhciScript :: [Char] -> DynFlags -> DynFlags
addGhciScript [Char]
f DynFlags
d = DynFlags
d { ghciScripts = f : ghciScripts d}

setInteractivePrint :: [Char] -> DynFlags -> DynFlags
setInteractivePrint [Char]
f DynFlags
d = DynFlags
d { interactivePrint = Just 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, TurnOnFlag)
updOptLevelChanged Int
n DynFlags
dfs
  = (DynFlags
dfs3, TurnOnFlag
changed1 TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| TurnOnFlag
changed2 TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| TurnOnFlag
changed3)
  where
   final_n :: Int
final_n = Int -> Int -> Int
forall a. Ord a => a -> a -> a
max Int
0 (Int -> Int -> Int
forall a. Ord a => a -> a -> a
min Int
2 Int
n)    -- Clamp to 0 <= n <= 2
   (DynFlags
dfs1, TurnOnFlag
changed1) = (GeneralFlag -> (DynFlags, TurnOnFlag) -> (DynFlags, TurnOnFlag))
-> (DynFlags, TurnOnFlag)
-> [GeneralFlag]
-> (DynFlags, TurnOnFlag)
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> (DynFlags, TurnOnFlag) -> (DynFlags, TurnOnFlag)
unset (DynFlags
dfs , TurnOnFlag
False) [GeneralFlag]
remove_gopts
   (DynFlags
dfs2, TurnOnFlag
changed2) = (GeneralFlag -> (DynFlags, TurnOnFlag) -> (DynFlags, TurnOnFlag))
-> (DynFlags, TurnOnFlag)
-> [GeneralFlag]
-> (DynFlags, TurnOnFlag)
forall a b. (a -> b -> b) -> b -> [a] -> b
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr GeneralFlag -> (DynFlags, TurnOnFlag) -> (DynFlags, TurnOnFlag)
set   (DynFlags
dfs1, TurnOnFlag
False) [GeneralFlag]
extra_gopts
   (DynFlags
dfs3, TurnOnFlag
changed3) = DynFlags -> (DynFlags, TurnOnFlag)
setLlvmOptLevel DynFlags
dfs2

   extra_gopts :: [GeneralFlag]
extra_gopts  = [ GeneralFlag
f | ([Int]
ns,GeneralFlag
f) <- [([Int], GeneralFlag)]
optLevelFlags, Int
final_n Int -> [Int] -> TurnOnFlag
forall a. Eq a => a -> [a] -> TurnOnFlag
forall (t :: * -> *) a.
(Foldable t, Eq a) =>
a -> t a -> TurnOnFlag
`elem` [Int]
ns ]
   remove_gopts :: [GeneralFlag]
remove_gopts = [ GeneralFlag
f | ([Int]
ns,GeneralFlag
f) <- [([Int], GeneralFlag)]
optLevelFlags, Int
final_n Int -> [Int] -> TurnOnFlag
forall (t :: * -> *) a.
(Foldable t, Eq a) =>
a -> t a -> TurnOnFlag
`notElem` [Int]
ns ]

   set :: GeneralFlag -> (DynFlags, TurnOnFlag) -> (DynFlags, TurnOnFlag)
set GeneralFlag
f (DynFlags
dfs, TurnOnFlag
changed)
     | GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
f DynFlags
dfs = (DynFlags
dfs, TurnOnFlag
changed)
     | TurnOnFlag
otherwise = (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dfs GeneralFlag
f, TurnOnFlag
True)

   unset :: GeneralFlag -> (DynFlags, TurnOnFlag) -> (DynFlags, TurnOnFlag)
unset GeneralFlag
f (DynFlags
dfs, TurnOnFlag
changed)
     | TurnOnFlag -> TurnOnFlag
not (GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
f DynFlags
dfs) = (DynFlags
dfs, TurnOnFlag
changed)
     | TurnOnFlag
otherwise = (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dfs GeneralFlag
f, TurnOnFlag
True)

   setLlvmOptLevel :: DynFlags -> (DynFlags, TurnOnFlag)
setLlvmOptLevel DynFlags
dfs
     | DynFlags -> Int
llvmOptLevel DynFlags
dfs Int -> Int -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
/= Int
final_n = (DynFlags
dfs{ llvmOptLevel = final_n }, TurnOnFlag
True)
     | TurnOnFlag
otherwise = (DynFlags
dfs, TurnOnFlag
False)

updOptLevel :: Int -> DynFlags -> DynFlags
-- ^ Sets the 'DynFlags' to be appropriate to the optimisation level
updOptLevel :: Int -> DynFlags -> DynFlags
updOptLevel Int
n = (DynFlags, TurnOnFlag) -> DynFlags
forall a b. (a, b) -> a
fst ((DynFlags, TurnOnFlag) -> DynFlags)
-> (DynFlags -> (DynFlags, TurnOnFlag)) -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> DynFlags -> (DynFlags, TurnOnFlag)
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], Messages DriverMessage)
                            -- ^ Updated 'DynFlags', left-over arguments, and
                            -- list of warnings.
parseDynamicFlagsCmdLine :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
parseDynamicFlagsCmdLine = [Flag (CmdLineP DynFlags)]
-> TurnOnFlag
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> TurnOnFlag
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
flagsAll TurnOnFlag
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], Messages DriverMessage)
                          -- ^ Updated 'DynFlags', left-over arguments, and
                          -- list of warnings.
parseDynamicFilePragma :: forall (m :: * -> *).
MonadIO m =>
DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
parseDynamicFilePragma = [Flag (CmdLineP DynFlags)]
-> TurnOnFlag
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> TurnOnFlag
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
flagsDynamic TurnOnFlag
False

newtype CmdLineP s a = CmdLineP (forall m. (Monad m) => StateT s m a)
  deriving ((forall a b. (a -> b) -> CmdLineP s a -> CmdLineP s b)
-> (forall a b. a -> CmdLineP s b -> CmdLineP s a)
-> Functor (CmdLineP s)
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
$cfmap :: forall s a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
fmap :: forall a b. (a -> b) -> CmdLineP s a -> CmdLineP s b
$c<$ :: forall s a b. a -> CmdLineP s b -> CmdLineP s a
<$ :: forall a b. a -> CmdLineP s b -> CmdLineP s a
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 (m :: * -> *). Monad m => StateT s m b) -> CmdLineP s b
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (StateT s m a
forall (m :: * -> *). Monad m => StateT s m a
k StateT s m a -> (a -> StateT s m b) -> StateT s m b
forall a b. StateT s m a -> (a -> StateT s m b) -> StateT s m b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \a
x -> case a -> CmdLineP s b
f a
x of CmdLineP forall (m :: * -> *). Monad m => StateT s m b
g -> StateT s m b
forall (m :: * -> *). Monad m => StateT s m b
g)
    return :: forall a. a -> CmdLineP s a
return = a -> CmdLineP s a
forall a. a -> CmdLineP s a
forall (f :: * -> *) a. Applicative f => a -> f a
pure

instance Applicative (CmdLineP s) where
    pure :: forall a. a -> CmdLineP s a
pure a
x = (forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (a -> StateT s m a
forall a. a -> StateT s m a
forall (f :: * -> *) a. Applicative f => a -> f a
pure a
x)
    <*> :: forall a b. CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b
(<*>) = CmdLineP s (a -> b) -> CmdLineP s a -> CmdLineP s b
forall (m :: * -> *) a b. Monad m => m (a -> b) -> m a -> m b
ap

getCmdLineState :: CmdLineP s s
getCmdLineState :: forall s. CmdLineP s s
getCmdLineState = (forall (m :: * -> *). Monad m => StateT s m s) -> CmdLineP s s
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP StateT s m s
forall (m :: * -> *). Monad m => StateT s m s
forall (m :: * -> *) s. Monad m => StateT s m s
State.get

putCmdLineState :: s -> CmdLineP s ()
putCmdLineState :: forall s. s -> CmdLineP s ()
putCmdLineState s
x = (forall (m :: * -> *). Monad m => StateT s m ()) -> CmdLineP s ()
forall s a.
(forall (m :: * -> *). Monad m => StateT s m a) -> CmdLineP s a
CmdLineP (s -> StateT s m ()
forall (m :: * -> *) s. Monad m => s -> StateT s m ()
State.put s
x)

runCmdLineP :: CmdLineP s a -> s -> (a, s)
runCmdLineP :: forall s a. CmdLineP s a -> s -> (a, s)
runCmdLineP (CmdLineP forall (m :: * -> *). Monad m => StateT s m a
k) s
s0 = Identity (a, s) -> (a, s)
forall a. Identity a -> a
runIdentity (Identity (a, s) -> (a, s)) -> Identity (a, s) -> (a, s)
forall a b. (a -> b) -> a -> b
$ StateT s Identity a -> s -> Identity (a, s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT s Identity a
forall (m :: * -> *). Monad m => StateT s m a
k s
s0

-- | 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 =
    StateT s m ([Located [Char]], [Err], [Warn])
-> s -> m (([Located [Char]], [Err], [Warn]), s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT ([Flag (StateT s m)]
-> [Located [Char]]
-> ([Char] -> EwM (StateT s m) [Located [Char]])
-> StateT s m ([Located [Char]], [Err], [Warn])
forall (m :: * -> *).
Monad m =>
[Flag m]
-> [Located [Char]]
-> ([Char] -> EwM m [Located [Char]])
-> m ([Located [Char]], [Err], [Warn])
processArgs ((Flag (CmdLineP s) -> Flag (StateT s m))
-> [Flag (CmdLineP s)] -> [Flag (StateT s m)]
forall a b. (a -> b) -> [a] -> [b]
map ((forall a. CmdLineP s a -> StateT s m a)
-> Flag (CmdLineP s) -> Flag (StateT s m)
forall (m :: * -> *) (n :: * -> *).
(forall a. m a -> n a) -> Flag m -> Flag n
hoistFlag CmdLineP s a -> StateT s m a
forall a. CmdLineP s a -> StateT s m a
getCmdLineP) [Flag (CmdLineP s)]
activeFlags) [Located [Char]]
args [Char] -> EwM (StateT s m) [Located [Char]]
forall (m :: * -> *). MonadIO m => [Char] -> EwM m [Located [Char]]
parseResponseFile) s
s0
  where
    getCmdLineP :: CmdLineP s a -> StateT s m a
    getCmdLineP :: forall a. CmdLineP s a -> StateT s m a
getCmdLineP (CmdLineP forall (m :: * -> *). Monad m => StateT s m a
k) = StateT s m a
forall (m :: * -> *). Monad m => StateT s m a
k

-- | 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], Messages DriverMessage)
parseDynamicFlagsFull :: forall (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP DynFlags)]
-> TurnOnFlag
-> DynFlags
-> [Located [Char]]
-> m (DynFlags, [Located [Char]], Messages DriverMessage)
parseDynamicFlagsFull [Flag (CmdLineP DynFlags)]
activeFlags TurnOnFlag
cmdline DynFlags
dflags0 [Located [Char]]
args = do
  ((leftover, errs, cli_warns), dflags1) <- [Flag (CmdLineP DynFlags)]
-> DynFlags
-> [Located [Char]]
-> m (([Located [Char]], [Err], [Warn]), DynFlags)
forall s (m :: * -> *).
MonadIO m =>
[Flag (CmdLineP s)]
-> s
-> [Located [Char]]
-> m (([Located [Char]], [Err], [Warn]), s)
processCmdLineP [Flag (CmdLineP DynFlags)]
activeFlags DynFlags
dflags0 [Located [Char]]
args

  -- See Note [Handling errors when parsing command-line flags]
  let rdr = SDocContext -> SDoc -> [Char]
renderWithContext (DynFlags -> PprStyle -> SDocContext
initSDocContext DynFlags
dflags0 PprStyle
defaultUserStyle)
  unless (null errs) $ liftIO $ throwGhcExceptionIO $ errorsToGhcException $
    map ((rdr . ppr . getLoc &&& unLoc) . errMsg) $ errs

  -- check for disabled flags in safe haskell
  let (dflags2, sh_warns) = safeFlagCheck cmdline dflags1
      theWays = DynFlags -> Set Way
ways DynFlags
dflags2

  unless (allowed_combination theWays) $ liftIO $
      throwGhcExceptionIO (CmdLineError ("combination not supported: " ++
                               intercalate "/" (map wayDesc (Set.toAscList theWays))))

  let (dflags3, consistency_warnings) = makeDynFlagsConsistent dflags2

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

  liftIO $ setUnsafeGlobalDynFlags dflags3

  -- create message envelopes using final DynFlags: #23402
  let diag_opts = DynFlags -> DiagOpts
initDiagOpts DynFlags
dflags3
      warns = DiagOpts -> [Warn] -> Messages DriverMessage
warnsToMessages DiagOpts
diag_opts ([Warn] -> Messages DriverMessage)
-> [Warn] -> Messages DriverMessage
forall a b. (a -> b) -> a -> b
$ [[Warn]] -> [Warn]
forall a. Monoid a => [a] -> a
mconcat [[Warn]
consistency_warnings, [Warn]
sh_warns, [Warn]
cli_warns]

  return (dflags3, leftover, 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, [Warn])
safeFlagCheck :: TurnOnFlag -> DynFlags -> (DynFlags, [Warn])
safeFlagCheck TurnOnFlag
_ DynFlags
dflags | DynFlags -> TurnOnFlag
safeLanguageOn DynFlags
dflags = (DynFlags
dflagsUnset, [Warn]
warns)
  where
    -- Handle illegal flags under safe language.
    (DynFlags
dflagsUnset, [Warn]
warns) = ((DynFlags, [Warn])
 -> (Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
     DynFlags -> DynFlags)
 -> (DynFlags, [Warn]))
-> (DynFlags, [Warn])
-> [(Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
     DynFlags -> DynFlags)]
-> (DynFlags, [Warn])
forall b a. (b -> a -> b) -> b -> [a] -> b
forall (t :: * -> *) b a.
Foldable t =>
(b -> a -> b) -> b -> t a -> b
foldl' (DynFlags, [Warn])
-> (Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
    DynFlags -> DynFlags)
-> (DynFlags, [Warn])
forall {a} {l}.
(a, [GenLocated l DriverMessage])
-> (Extension, a -> l, a -> TurnOnFlag, a -> a)
-> (a, [GenLocated l DriverMessage])
check_method (DynFlags
dflags, [Warn]
forall a. Monoid a => a
mempty) [(Extension, DynFlags -> SrcSpan, DynFlags -> TurnOnFlag,
  DynFlags -> DynFlags)]
unsafeFlags

    check_method :: (a, [GenLocated l DriverMessage])
-> (Extension, a -> l, a -> TurnOnFlag, a -> a)
-> (a, [GenLocated l DriverMessage])
check_method (a
df, [GenLocated l DriverMessage]
warns) (Extension
ext,a -> l
loc,a -> TurnOnFlag
test,a -> a
fix)
        | a -> TurnOnFlag
test a
df   = (a -> a
fix a
df, l -> Extension -> GenLocated l DriverMessage
forall {l}. l -> Extension -> GenLocated l DriverMessage
safeFailure (a -> l
loc a
df) Extension
ext GenLocated l DriverMessage
-> [GenLocated l DriverMessage] -> [GenLocated l DriverMessage]
forall a. a -> [a] -> [a]
:  [GenLocated l DriverMessage]
warns)
        | TurnOnFlag
otherwise = (a
df, [GenLocated l DriverMessage]
warns)

    safeFailure :: l -> Extension -> GenLocated l DriverMessage
safeFailure l
loc Extension
ext
       = l -> DriverMessage -> GenLocated l DriverMessage
forall l e. l -> e -> GenLocated l e
L l
loc (DriverMessage -> GenLocated l DriverMessage)
-> DriverMessage -> GenLocated l DriverMessage
forall a b. (a -> b) -> a -> b
$ Extension -> DriverMessage
DriverSafeHaskellIgnoredExtension Extension
ext

safeFlagCheck TurnOnFlag
cmdl DynFlags
dflags =
  case DynFlags -> TurnOnFlag
safeInferOn DynFlags
dflags of
    TurnOnFlag
True   -> (DynFlags
dflags' { safeInferred = safeFlags }, [Warn]
warn)
    TurnOnFlag
False  -> (DynFlags
dflags', [Warn]
warn)

  where
    -- dynflags and warn for when -fpackage-trust by itself with no safe
    -- haskell flag
    (DynFlags
dflags', [Warn]
warn)
      | TurnOnFlag -> TurnOnFlag
not (DynFlags -> TurnOnFlag
safeHaskellModeEnabled DynFlags
dflags) TurnOnFlag -> TurnOnFlag -> TurnOnFlag
&& TurnOnFlag -> TurnOnFlag
not TurnOnFlag
cmdl TurnOnFlag -> TurnOnFlag -> TurnOnFlag
&& DynFlags -> TurnOnFlag
packageTrustOn DynFlags
dflags
      = (DynFlags -> GeneralFlag -> DynFlags
gopt_unset DynFlags
dflags GeneralFlag
Opt_PackageTrust, [Warn]
pkgWarnMsg)
      | TurnOnFlag
otherwise = (DynFlags
dflags, [Warn]
forall a. Monoid a => a
mempty)

    pkgWarnMsg :: [Warn]
    pkgWarnMsg :: [Warn]
pkgWarnMsg = [ SrcSpan -> DriverMessage -> Warn
forall l e. l -> e -> GenLocated l e
L (DynFlags -> SrcSpan
pkgTrustOnLoc DynFlags
dflags') DriverMessage
DriverPackageTrustIgnored ]

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

-- | Produce a list of suggestions for a user provided flag that is invalid.
flagSuggestions
  :: [String] -- valid flags to match against
  -> String
  -> [String]
flagSuggestions :: [[Char]] -> [Char] -> [[Char]]
flagSuggestions [[Char]]
flags [Char]
userInput
  -- fixes #11789
  -- If the flag contains '=',
  -- this uses both the whole and the left side of '=' for comparing.
  | Char -> [Char] -> TurnOnFlag
forall a. Eq a => a -> [a] -> TurnOnFlag
forall (t :: * -> *) a.
(Foldable t, Eq a) =>
a -> t a -> TurnOnFlag
elem Char
'=' [Char]
userInput =
        let ([[Char]]
flagsWithEq, [[Char]]
flagsWithoutEq) = ([Char] -> TurnOnFlag) -> [[Char]] -> ([[Char]], [[Char]])
forall a. (a -> TurnOnFlag) -> [a] -> ([a], [a])
partition (Char -> [Char] -> TurnOnFlag
forall a. Eq a => a -> [a] -> TurnOnFlag
forall (t :: * -> *) a.
(Foldable t, Eq a) =>
a -> t a -> TurnOnFlag
elem Char
'=') [[Char]]
flags
            fName :: [Char]
fName = (Char -> TurnOnFlag) -> [Char] -> [Char]
forall a. (a -> TurnOnFlag) -> [a] -> [a]
takeWhile (Char -> Char -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
/= Char
'=') [Char]
userInput
        in ([Char] -> [[Char]] -> [[Char]]
fuzzyMatch [Char]
userInput [[Char]]
flagsWithEq) [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++ ([Char] -> [[Char]] -> [[Char]]
fuzzyMatch [Char]
fName [[Char]]
flagsWithoutEq)
  | TurnOnFlag
otherwise = [Char] -> [[Char]] -> [[Char]]
fuzzyMatch [Char]
userInput [[Char]]
flags

{- **********************************************************************
%*                                                                      *
                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 = TurnOnFlag -> [[Char]]
allFlagsDeps TurnOnFlag
False

-- | All flags with possibility to filter deprecated ones
allFlagsDeps :: Bool -> [String]
allFlagsDeps :: TurnOnFlag -> [[Char]]
allFlagsDeps TurnOnFlag
keepDeprecated = [ Char
'-'Char -> [Char] -> [Char]
forall a. a -> [a] -> [a]
:Flag (CmdLineP DynFlags) -> [Char]
forall (m :: * -> *). Flag m -> [Char]
flagName Flag (CmdLineP DynFlags)
flag
                              | (Deprecation
deprecated, Flag (CmdLineP DynFlags)
flag) <- [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps
                              , TurnOnFlag
keepDeprecated TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| TurnOnFlag -> TurnOnFlag
not (Deprecation -> TurnOnFlag
isDeprecated Deprecation
deprecated)]
  where isDeprecated :: Deprecation -> TurnOnFlag
isDeprecated Deprecation
Deprecated = TurnOnFlag
True
        isDeprecated Deprecation
_ = TurnOnFlag
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 = ((Deprecation, Flag (CmdLineP DynFlags))
 -> Flag (CmdLineP DynFlags))
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [Flag (CmdLineP DynFlags)]
forall a b. (a -> b) -> [a] -> [b]
map (Deprecation, Flag (CmdLineP DynFlags)) -> Flag (CmdLineP DynFlags)
forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
flagsAllDeps

-- 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 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
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 = ((Deprecation, Flag (CmdLineP DynFlags))
 -> Flag (CmdLineP DynFlags))
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [Flag (CmdLineP DynFlags)]
forall a b. (a -> b) -> [a] -> [b]
map (Deprecation, Flag (CmdLineP DynFlags)) -> Flag (CmdLineP DynFlags)
forall a b. (a, b) -> b
snd [(Deprecation, Flag (CmdLineP DynFlags))]
dynamic_flags_deps

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

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

type FlagMaker m = String -> OptKind m -> Flag m
type DynFlagMaker = FlagMaker (CmdLineP DynFlags)

-- 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 (OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags))
-> OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ OptKind (CmdLineP DynFlags)
-> [Char] -> OptKind (CmdLineP DynFlags)
add_dep_message OptKind (CmdLineP DynFlags)
kind [Char]
message)

add_dep_message :: OptKind (CmdLineP DynFlags) -> String
                -> OptKind (CmdLineP DynFlags)
add_dep_message :: OptKind (CmdLineP DynFlags)
-> [Char] -> OptKind (CmdLineP DynFlags)
add_dep_message (NoArg DynP ()
f) [Char]
message = DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ DynP ()
f DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (HasArg [Char] -> DynP ()
f) [Char]
message = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (SepArg [Char] -> DynP ()
f) [Char]
message = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (Prefix [Char] -> DynP ()
f) [Char]
message = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (OptPrefix [Char] -> DynP ()
f) [Char]
message =
                                  ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
OptPrefix (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (OptIntSuffix Maybe Int -> DynP ()
f) [Char]
message =
                               (Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix ((Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Maybe Int
oi -> Maybe Int -> DynP ()
f Maybe Int
oi DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (IntSuffix Int -> DynP ()
f) [Char]
message =
                                  (Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Int -> EwM m ()) -> OptKind m
IntSuffix ((Int -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Int
i -> Int -> DynP ()
f Int
i DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (Word64Suffix Word64 -> DynP ()
f) [Char]
message =
                                  (Word64 -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Word64 -> EwM m ()) -> OptKind m
Word64Suffix ((Word64 -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Word64 -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Word64
i -> Word64 -> DynP ()
f Word64
i DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (FloatSuffix Float -> DynP ()
f) [Char]
message =
                                (Float -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Float -> EwM m ()) -> OptKind m
FloatSuffix ((Float -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> (Float -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \Float
fl -> Float -> DynP ()
f Float
fl DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (PassFlag [Char] -> DynP ()
f) [Char]
message =
                                   ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
PassFlag (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
deprecate [Char]
message
add_dep_message (AnySuffix [Char] -> DynP ()
f) [Char]
message =
                                  ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
AnySuffix (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
s -> [Char] -> DynP ()
f [Char]
s DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> [Char] -> DynP ()
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"n" (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ () -> DynP ()
forall a. a -> EwM (CmdLineP DynFlags) a
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"cpp"      (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"F"        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Pp))
  , (Deprecation
Deprecated, DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"#include"
      (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
_s ->
         [Char] -> DynP ()
deprecate ([Char]
"-#include and INCLUDE pragmas are " [Char] -> [Char] -> [Char]
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"v"        ((Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"j"     ((Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix
        (\Maybe Int
n -> case Maybe Int
n of
                 Just Int
n
                     | Int
n Int -> Int -> TurnOnFlag
forall a. Ord a => a -> a -> TurnOnFlag
> Int
0     -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { parMakeCount = Just (ParMakeThisMany n) })
                     | TurnOnFlag
otherwise -> [Char] -> DynP ()
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 = Just ParMakeNumProcessors })))
                 -- 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"jsem" (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f DynFlags
d -> DynFlags
d { parMakeCount = Just (ParMakeSemaphore f) }

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"H"           (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
s -> (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d ->
          DynFlags
d { ghcHeapSize = Just $ fromIntegral (decodeSize s)})))

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

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

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_Ticky DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"static"         (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
removeWayDynP Way
WayDyn))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynamic"        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (Way -> DynP ()
addWayDynP Way
WayDyn))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rdynamic" (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"relative-dynlib-paths"
      (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"copy-libs-when-linking"
      (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"pie"            (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-pie"         (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlo"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_lo  = (f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlc"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_lc  = (f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlas"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_las  = (f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmlm"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_lm  =
          if null f then Nothing else Just (f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmi"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_i   =  f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmL"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_L   = f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmJSP"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setPgmJSP)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmCmmP"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
setPgmCmmP)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmF"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_F   = f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmc"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_c   = f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmcxx"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_cxx = f }
  , (Deprecation
Deprecated, DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag  [Char]
"pgmc-supports-no-pie"
      (OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags))
-> OptKind (CmdLineP DynFlags) -> Flag (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
noArgM  ((DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags))
-> (DynFlags -> DynP DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> do
        [Char] -> DynP ()
deprecate ([Char] -> DynP ()) -> [Char] -> DynP ()
forall a b. (a -> b) -> a -> b
$ [Char]
"use -pgml-supports-no-pie instead"
        DynFlags -> DynP DynFlags
forall a. a -> EwM (CmdLineP DynFlags) a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (DynFlags -> DynP DynFlags) -> DynFlags -> DynP DynFlags
forall a b. (a -> b) -> a -> b
$ (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings (\ToolSettings
s -> ToolSettings
s { toolSettings_ccSupportsNoPie = True }) DynFlags
d)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgms"
      (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg (\[Char]
_ -> [Char] -> DynP ()
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgma"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_a   = (f,[]) }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgml"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s
         { toolSettings_pgm_l   = (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 = False
         }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgml-supports-no-pie"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> (DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_ccSupportsNoPie = True }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmwindres"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_windres = f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmar"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_ar = f }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmotool"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_otool = f}
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgminstall_name_tool"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_install_name_tool = f}
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"pgmranlib"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_pgm_ranlib = 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlm"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_lm  = f : toolSettings_opt_lm s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlo"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_lo  = f : toolSettings_opt_lo s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlc"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_lc  = f : toolSettings_opt_lc s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optlas"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_las  = f : toolSettings_opt_las s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"opti"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_i   = f : toolSettings_opt_i s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optL"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_L   = f : toolSettings_opt_L s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optJSP"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addOptJSP)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optCmmP"
      (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
addOptCmmP)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optF"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_F   = f : toolSettings_opt_F s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"opta"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f -> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_a   = f : toolSettings_opt_a s }
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"optwindres"
      (OptKind (CmdLineP DynFlags)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall a b. (a -> b) -> a -> b
$ ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags))
-> ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ \[Char]
f ->
        (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
alterToolSettings ((ToolSettings -> ToolSettings) -> DynFlags -> DynFlags)
-> (ToolSettings -> ToolSettings) -> DynFlags -> DynFlags
forall a b. (a -> b) -> a -> b
$ \ToolSettings
s -> ToolSettings
s { toolSettings_opt_windres = f : toolSettings_opt_windres s }

    -- 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"split-sections"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_SplitSections)

        -------- ghc -M -----------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"include-cpp-deps"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (TurnOnFlag -> DynFlags -> DynFlags
setDepIncludeCppDeps TurnOnFlag
True))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"include-pkg-deps"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (TurnOnFlag -> DynFlags -> DynFlags
setDepIncludePkgDeps TurnOnFlag
True))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-link"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink=NoLink }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"shared"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink=LinkDynLib }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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=LinkStaticLib })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"-merge-objs"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { ghcLink=LinkMergedObj }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"L"   (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix [Char] -> DynP ()
addLibraryPath)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"l"   (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Option -> DynFlags -> DynFlags
addLdInputs (Option -> DynFlags -> DynFlags)
-> ([Char] -> Option) -> [Char] -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Option
Option ([Char] -> Option) -> ([Char] -> [Char]) -> [Char] -> Option
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char]
"-l" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++)))

        ------- Frameworks --------------------------------------------------
        -- -framework-path should really be -F ...
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"framework-path" (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
addFrameworkPath)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"o"                 (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (Maybe [Char] -> DynFlags -> DynFlags
setOutputFile (Maybe [Char] -> DynFlags -> DynFlags)
-> ([Char] -> Maybe [Char]) -> [Char] -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dyno"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg (Maybe [Char] -> DynFlags -> DynFlags
setDynOutputFile (Maybe [Char] -> DynFlags -> DynFlags)
-> ([Char] -> Maybe [Char]) -> [Char] -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ohi"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Maybe [Char] -> DynFlags -> DynFlags
setOutputHi (Maybe [Char] -> DynFlags -> DynFlags)
-> ([Char] -> Maybe [Char]) -> [Char] -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynohi"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Maybe [Char] -> DynFlags -> DynFlags
setDynOutputHi (Maybe [Char] -> DynFlags -> DynFlags)
-> ([Char] -> Maybe [Char]) -> [Char] -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-file-prefix"
        (([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg (Maybe [Char] -> DynFlags -> DynFlags
setDumpPrefixForce (Maybe [Char] -> DynFlags -> DynFlags)
-> ([Char] -> Maybe [Char]) -> [Char] -> DynFlags -> DynFlags
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ([Char] -> Maybe [Char])
-> ([Char] -> [Char]) -> [Char] -> Maybe [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Char] -> [Char] -> [Char]) -> [Char] -> [Char] -> [Char]
forall a b c. (a -> b -> c) -> b -> a -> c
flip [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
(++) [Char]
"."))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dynamic-too"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hc-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hc-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hscpp-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hscpp-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-s-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-s-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-llvm-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ Backend -> DynP ()
setObjBackend Backend
llvmBackend DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepLlvmFiles)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-llvm-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ Backend -> DynP ()
setObjBackend Backend
llvmBackend DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_KeepLlvmFiles)
     -- This only makes sense as plural
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-tmp-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hi-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-hi-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-hi-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-hi-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-o-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-o-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"keep-o-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-keep-o-files"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-auto-link-packages"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-hs-main"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-state-hack"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fno-opt-coercion"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"with-rtsopts"
        (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
setRtsOpts)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsAll))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=all"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsAll))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=some"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsSafeOnly))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=none"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsNone))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=ignore"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsIgnore))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"rtsopts=ignoreAll"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsIgnoreAll))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-rtsopts"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (RtsOptsEnabled -> DynP ()
setRtsOptsEnabled RtsOptsEnabled
RtsOptsNone))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-rtsopts-suggestions"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d {rtsOptsSuggestions = False}))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dhex-word-literals"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"main-is"              (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg [Char] -> DynP ()
setMainIs)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"haddock"              (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-haddock"           (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"hpcdir"               (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg [Char] -> DynP ()
setOptHpcDir)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-allocd"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-LNE"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-ap-thunk"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-dyn-thunk"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ticky-tag-checks"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"recomp"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"no-recomp"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_ForceRecomp) [Char]
"Use -fforce-recomp instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 = Just (max 1 n) }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-max-errors"
      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { maxErrors = Nothing }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"freverse-errors"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d {reverseErrors = True} ))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-reverse-errors"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d {reverseErrors = False} ))

        ------ HsCpp opts ---------------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"D"              (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
AnySuffix ((DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> ([Char] -> DynFlags -> DynFlags) -> [Char] -> DynP ()
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"U"              (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
AnySuffix ((DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> ([Char] -> DynFlags -> DynFlags) -> [Char] -> DynP ()
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"I"              (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix    [Char] -> DynP ()
addIncludePath)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"i"              (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 = n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 = n }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdiagnostics-color=auto"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useColor = Auto })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdiagnostics-color=always"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useColor = Always })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fdiagnostics-color=never"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useColor = Never })))

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fprint-error-index-links=auto"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useErrorLinks = Auto })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fprint-error-index-links=always"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useErrorLinks = Always })))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fprint-error-index-links=never"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg ((DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
d -> DynFlags
d { useErrorLinks = 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dsuppress-all"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ 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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dstg-stats"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-llvm"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_llvm)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-c-backend"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_dump_c_backend)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dkeep-comments"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-spec-constr"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_spec_constr)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-stranal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_dmdanal)
        [Char]
"Use `-ddump-dmdanal` instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-str-signatures"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_dmd_signatures)
        [Char]
"Use `-ddump-dmd-signatures` instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-dmdanal"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_dmdanal)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-dmd-signatures"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_dmd_signatures)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-float-out"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_float_out)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-full-laziness"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_float_out)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-float-in"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_float_in)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-liberate-case"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_liberate_case)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-static-argument-transformation"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_static_argument_transformation)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-tc-trace"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dverbose-core2core"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ Maybe Int -> DynP ()
setVerbosity (Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2) DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> DumpFlag -> DynP ()
setDumpFlag' DumpFlag
Opt_D_verbose_core2core)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-minimal-imports"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-to-file"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dlint"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
enableDLint)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dcore-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dlinear-core-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dstg-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dcmm-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dasm-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dannot-lint"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dtag-inference-checks"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dshow-passes"
        (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (DynP () -> OptKind (CmdLineP DynFlags))
-> DynP () -> OptKind (CmdLineP DynFlags)
forall a b. (a -> b) -> a -> b
$ DynP ()
forceRecompile DynP () -> DynP () -> DynP ()
forall a b.
EwM (CmdLineP DynFlags) a
-> EwM (CmdLineP DynFlags) b -> EwM (CmdLineP DynFlags) b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> (Maybe Int -> DynP ()
setVerbosity (Maybe Int -> DynP ()) -> Maybe Int -> DynP ()
forall a b. (a -> b) -> a -> b
$ Int -> Maybe Int
forall a. a -> Maybe a
Just Int
2))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dipe-stats"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_ipe_stats)
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dno-llvm-mangler"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"dno-typeable-binds"
        (DynP () -> OptKind (CmdLineP DynFlags)
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 DynFlagMaker
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)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddump-json"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_json)
        [Char]
"Use `-fdiagnostics-as-json` instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"ddebug-output"
        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg ((DynFlags -> DumpFlag -> DynFlags)
-> DumpFlag -> DynFlags -> DynFlags
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 DynFlagMaker
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 DynFlagMaker
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 DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion = Just SSE1 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse2"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion = Just SSE2 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse3"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion = Just SSE3 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse4"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                  DynFlags
d { sseVersion = Just SSE4 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"msse4.2"      ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                 DynFlags
d { sseVersion = Just SSE42 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mbmi"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                 DynFlags
d { bmiVersion = Just BMI1 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mbmi2"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)