{-# 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,

        -- ** base
        baseUnitId,

        -- ** 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,
        sTargetRTSLinkerOnlySupportsSharedLibs,
        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
  , sUnitSettings :: UnitSettings
sUnitSettings = DynFlags -> UnitSettings
unitSettings 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


setBaseUnitId :: String -> DynP ()
setBaseUnitId :: [Char] -> DynP ()
setBaseUnitId [Char]
s = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { unitSettings = UnitSettings (stringToUnitId s) }

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

{-
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-stg-from-js-sinker"
        (DumpFlag -> OptKind (CmdLineP DynFlags)
setDumpFlag DumpFlag
Opt_D_dump_stg_from_js_sinker)
  , 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)
noArg (\DynFlags
d ->
                                                 DynFlags
d { bmiVersion = Just BMI2 }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { avx = True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx2"        ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { avx2 = True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512cd"    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                         DynFlags
d { avx512cd = True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512er"    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                         DynFlags
d { avx512er = True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512f"     ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { avx512f = True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mavx512pf"    ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d ->
                                                         DynFlags
d { avx512pf = True }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"mfma"         ((DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
noArg (\DynFlags
d -> DynFlags
d { fma = True }))

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

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

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

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

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

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fwrite-if-compression"
      ((Int -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
intSuffix (\Int
n DynFlags
d -> DynFlags
d { ifCompression = n }))

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

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

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

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

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

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

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

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

        -- Caller-CC
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"fprof-callers"
         (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg [Char] -> DynP ()
setCallerCcFilters)
        ------ Compiler flags -----------------------------------------------

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

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

  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fglasgow-exts"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
enableGlasgowExts) [Char]
"Use individual extensions instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"fno-glasgow-exts"
      (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg DynP ()
disableGlasgowExts) [Char]
"Use individual extensions instead"

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

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

         ------ Debugging flags ----------------------------------------------
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defGhcFlag [Char]
"g"             ((Maybe Int -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Maybe Int -> EwM m ()) -> OptKind m
OptIntSuffix Maybe Int -> DynP ()
setDebugLevel)
 ]
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec GeneralFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec GeneralFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
""          GeneralFlag -> DynP ()
setGeneralFlag    ) [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec GeneralFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec GeneralFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"no-"       GeneralFlag -> DynP ()
unSetGeneralFlag  ) [(Deprecation, FlagSpec GeneralFlag)]
negatableFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec GeneralFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec GeneralFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"d"         GeneralFlag -> DynP ()
setGeneralFlag    ) [(Deprecation, FlagSpec GeneralFlag)]
dFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec GeneralFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec GeneralFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"dno-"      GeneralFlag -> DynP ()
unSetGeneralFlag  ) [(Deprecation, FlagSpec GeneralFlag)]
dFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec GeneralFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec GeneralFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"f"         GeneralFlag -> DynP ()
setGeneralFlag    ) [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec GeneralFlag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec GeneralFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (GeneralFlag -> DynP ())
-> (Deprecation, FlagSpec GeneralFlag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"fno-"      GeneralFlag -> DynP ()
unSetGeneralFlag  ) [(Deprecation, FlagSpec GeneralFlag)]
fFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++

        ------ Warning flags -------------------------------------------------
  [ DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"W"       (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (WarningGroup -> DynP ()
setWarningGroup WarningGroup
W_extra))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Werror"
               (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (do { GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_WarnIsError
                          ; WarningGroup -> DynP ()
setFatalWarningGroup WarningGroup
W_everything }))
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wwarn"
               (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (do { GeneralFlag -> DynP ()
unSetGeneralFlag GeneralFlag
Opt_WarnIsError
                          ; WarningGroup -> DynP ()
unSetFatalWarningGroup WarningGroup
W_everything }))
                          -- Opt_WarnIsError is still needed to pass -Werror
                          -- to CPP; see runCpp in SysTools
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> [Char]
-> (Deprecation, Flag (CmdLineP DynFlags))
make_dep_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"Wnot"    (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (WarningGroup -> DynP ()
unSetWarningGroup WarningGroup
W_everything))
                                             [Char]
"Use -w or -Wno-everything instead"
  , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"w"       (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (WarningGroup -> DynP ()
unSetWarningGroup WarningGroup
W_everything))
  ]

     -- New-style uniform warning sets
     --
     -- Note that -Weverything > -Wall > -Wextra > -Wdefault > -Wno-everything
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ (WarningGroup -> DynP ())
-> (WarningGroup -> DynP ())
-> (WarningGroup -> DynP ())
-> (WarningGroup -> DynP ())
-> [(Deprecation, FlagSpec WarningGroup)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall warn_flag.
(warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
warningControls WarningGroup -> DynP ()
setWarningGroup WarningGroup -> DynP ()
unSetWarningGroup WarningGroup -> DynP ()
setWErrorWarningGroup WarningGroup -> DynP ()
unSetFatalWarningGroup [(Deprecation, FlagSpec WarningGroup)]
warningGroupsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ (WarningFlag -> DynP ())
-> (WarningFlag -> DynP ())
-> (WarningFlag -> DynP ())
-> (WarningFlag -> DynP ())
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall warn_flag.
(warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
warningControls WarningFlag -> DynP ()
setWarningFlag WarningFlag -> DynP ()
unSetWarningFlag WarningFlag -> DynP ()
setWErrorFlag WarningFlag -> DynP ()
unSetFatalWarningFlag [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ (WarningCategory -> DynP ())
-> (WarningCategory -> DynP ())
-> (WarningCategory -> DynP ())
-> (WarningCategory -> DynP ())
-> [(Deprecation, FlagSpec WarningCategory)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall warn_flag.
(warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
warningControls WarningCategory -> DynP ()
setCustomWarningFlag WarningCategory -> DynP ()
unSetCustomWarningFlag WarningCategory -> DynP ()
setCustomWErrorFlag WarningCategory -> DynP ()
unSetCustomFatalWarningFlag
      [(Deprecation
NotDeprecated, [Char]
-> WarningCategory
-> (TurnOnFlag -> DynP ())
-> GhcFlagMode
-> FlagSpec WarningCategory
forall flag.
[Char]
-> flag -> (TurnOnFlag -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
"warnings-deprecations" WarningCategory
defaultWarningCategory TurnOnFlag -> DynP ()
nop GhcFlagMode
AllModes)]
      -- See Note [Warning categories] in GHC.Unit.Module.Warnings.

 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ [ (Deprecation
NotDeprecated, [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"Wno-"       WarningCategory -> DynP ()
unSetCustomWarningFlag)
    , (Deprecation
NotDeprecated, [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"Werror="    WarningCategory -> DynP ()
setCustomWErrorFlag)
    , (Deprecation
NotDeprecated, [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"Wwarn="     WarningCategory -> DynP ()
unSetCustomFatalWarningFlag)
    , (Deprecation
NotDeprecated, [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"Wno-error=" WarningCategory -> DynP ()
unSetCustomFatalWarningFlag)
    , (Deprecation
NotDeprecated, [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"W"          WarningCategory -> DynP ()
setCustomWarningFlag)
    , (Deprecation
Deprecated,    [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"fwarn-"     WarningCategory -> DynP ()
setCustomWarningFlag)
    , (Deprecation
Deprecated,    [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
"fno-warn-"  WarningCategory -> DynP ()
unSetCustomWarningFlag)
    ]

     ------ JavaScript flags -----------------------------------------------
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ [ DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"ddisable-js-minifier" (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DisableJsMinifier))
    , DynFlagMaker
-> [Char]
-> OptKind (CmdLineP DynFlags)
-> (Deprecation, Flag (CmdLineP DynFlags))
make_ord_flag DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defFlag [Char]
"ddisable-js-c-sources" (DynP () -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). EwM m () -> OptKind m
NoArg (GeneralFlag -> DynP ()
setGeneralFlag GeneralFlag
Opt_DisableJsCsources))
    ]

     ------ Language flags -------------------------------------------------
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec Extension)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec Extension)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"f"         Extension -> DynP ()
setExtensionFlag  ) [(Deprecation, FlagSpec Extension)]
fLangFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec Extension)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec Extension)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"fno-"      Extension -> DynP ()
unSetExtensionFlag) [(Deprecation, FlagSpec Extension)]
fLangFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec Extension)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec Extension)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"X"         Extension -> DynP ()
setExtensionFlag  ) [(Deprecation, FlagSpec Extension)]
xFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec Extension)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec Extension)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (Extension -> DynP ())
-> (Deprecation, FlagSpec Extension)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"XNo"       Extension -> DynP ()
unSetExtensionFlag) [(Deprecation, FlagSpec Extension)]
xFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec Language)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec Language)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (Language -> DynP ())
-> (Deprecation, FlagSpec Language)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"X"         Language -> DynP ()
setLanguage       ) [(Deprecation, FlagSpec Language)]
languageFlagsDeps
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec SafeHaskellMode)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec SafeHaskellMode)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (SafeHaskellMode -> DynP ())
-> (Deprecation, FlagSpec SafeHaskellMode)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"X"         SafeHaskellMode -> DynP ()
setSafeHaskell    ) [(Deprecation, FlagSpec SafeHaskellMode)]
safeHaskellFlagsDeps

-- | Warnings have both new-style flags to control their state (@-W@, @-Wno-@,
-- @-Werror=@, @-Wwarn=@) and old-style flags (@-fwarn-@, @-fno-warn-@).  We
-- define these uniformly for individual warning flags and groups of warnings.
warningControls :: (warn_flag -> DynP ()) -- ^ Set the warning
                -> (warn_flag -> DynP ()) -- ^ Unset the warning
                -> (warn_flag -> DynP ()) -- ^ Make the warning an error
                -> (warn_flag -> DynP ()) -- ^ Clear the error status
                -> [(Deprecation, FlagSpec warn_flag)]
                -> [(Deprecation, Flag (CmdLineP DynFlags))]
warningControls :: forall warn_flag.
(warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> (warn_flag -> DynP ())
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
warningControls warn_flag -> DynP ()
set warn_flag -> DynP ()
unset warn_flag -> DynP ()
set_werror warn_flag -> DynP ()
unset_fatal [(Deprecation, FlagSpec warn_flag)]
xs =
    ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"W"          warn_flag -> DynP ()
set             ) [(Deprecation, FlagSpec warn_flag)]
xs
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"Wno-"       warn_flag -> DynP ()
unset           ) [(Deprecation, FlagSpec warn_flag)]
xs
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"Werror="    warn_flag -> DynP ()
set_werror      ) [(Deprecation, FlagSpec warn_flag)]
xs
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"Wwarn="     warn_flag -> DynP ()
unset_fatal     ) [(Deprecation, FlagSpec warn_flag)]
xs
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"Wno-error=" warn_flag -> DynP ()
unset_fatal     ) [(Deprecation, FlagSpec warn_flag)]
xs
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOn  [Char]
"fwarn-"     warn_flag -> DynP ()
set   ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> ((Deprecation, FlagSpec warn_flag)
    -> (Deprecation, FlagSpec warn_flag))
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Deprecation, FlagSpec warn_flag)
-> (Deprecation, FlagSpec warn_flag)
forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag) [(Deprecation, FlagSpec warn_flag)]
xs
 [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a. [a] -> [a] -> [a]
++ ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> [(Deprecation, FlagSpec warn_flag)]
-> [(Deprecation, Flag (CmdLineP DynFlags))]
forall a b. (a -> b) -> [a] -> [b]
map (TurnOnFlag
-> [Char]
-> (warn_flag -> DynP ())
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall flag.
TurnOnFlag
-> [Char]
-> (flag -> DynP ())
-> (Deprecation, FlagSpec flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
mkFlag TurnOnFlag
turnOff [Char]
"fno-warn-"  warn_flag -> DynP ()
unset ((Deprecation, FlagSpec warn_flag)
 -> (Deprecation, Flag (CmdLineP DynFlags)))
-> ((Deprecation, FlagSpec warn_flag)
    -> (Deprecation, FlagSpec warn_flag))
-> (Deprecation, FlagSpec warn_flag)
-> (Deprecation, Flag (CmdLineP DynFlags))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Deprecation, FlagSpec warn_flag)
-> (Deprecation, FlagSpec warn_flag)
forall a. (Deprecation, FlagSpec a) -> (Deprecation, FlagSpec a)
hideFlag) [(Deprecation, FlagSpec warn_flag)]
xs

-- | This is where we handle unrecognised warning flags. If the flag is valid as
-- an extended warning category, we call the supplied action. Otherwise, issue a
-- warning if -Wunrecognised-warning-flags is set. See #11429 for context.
-- See Note [Warning categories] in GHC.Unit.Module.Warnings.
customOrUnrecognisedWarning :: String -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning :: [Char] -> (WarningCategory -> DynP ()) -> Flag (CmdLineP DynFlags)
customOrUnrecognisedWarning [Char]
prefix WarningCategory -> DynP ()
custom = DynFlagMaker
forall (m :: * -> *). [Char] -> OptKind m -> Flag m
defHiddenFlag [Char]
prefix (([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
Prefix [Char] -> DynP ()
action)
  where
    action :: String -> DynP ()
    action :: [Char] -> DynP ()
action [Char]
flag
      | WarningCategory -> TurnOnFlag
validWarningCategory WarningCategory
cat = WarningCategory -> DynP ()
custom WarningCategory
cat
      | TurnOnFlag
otherwise = [Char] -> DynP ()
unrecognised [Char]
flag
      where
        cat :: WarningCategory
cat = FastString -> WarningCategory
mkWarningCategory ([Char] -> FastString
mkFastString [Char]
flag)

    unrecognised :: [Char] -> DynP ()
unrecognised [Char]
flag = do
      -- #23402 and #12056
      -- for unrecognised flags we consider current dynflags, not the final one.
      -- But if final state says to not report unrecognised flags, they won't anyway.
      f <- WarningFlag -> DynFlags -> TurnOnFlag
wopt WarningFlag
Opt_WarnUnrecognisedWarningFlags (DynFlags -> TurnOnFlag)
-> DynP DynFlags -> EwM (CmdLineP DynFlags) TurnOnFlag
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> CmdLineP DynFlags DynFlags -> DynP DynFlags
forall (m :: * -> *) a. Monad m => m a -> EwM m a
liftEwM CmdLineP DynFlags DynFlags
forall s. CmdLineP s s
getCmdLineState
      when f $ addFlagWarn (DriverUnrecognisedFlag (prefix ++ flag))

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

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

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

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

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

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

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

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

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

-- | Define a new deprecated flag with an effect.
depFlagSpecOp :: String -> flag -> (TurnOnFlag -> DynP ()) -> String
            -> (Deprecation, FlagSpec flag)
depFlagSpecOp :: forall flag.
[Char]
-> flag
-> (TurnOnFlag -> DynP ())
-> [Char]
-> (Deprecation, FlagSpec flag)
depFlagSpecOp [Char]
name flag
flag TurnOnFlag -> DynP ()
act [Char]
dep =
    (Deprecation
Deprecated, (Deprecation, FlagSpec flag) -> FlagSpec flag
forall a b. (a, b) -> b
snd ([Char]
-> flag -> (TurnOnFlag -> DynP ()) -> (Deprecation, FlagSpec flag)
forall flag.
[Char]
-> flag -> (TurnOnFlag -> DynP ()) -> (Deprecation, FlagSpec flag)
flagSpec' [Char]
name flag
flag (\TurnOnFlag
f -> TurnOnFlag -> DynP ()
act TurnOnFlag
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]
dep)))

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

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

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


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

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

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

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

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

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

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

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

deprecate :: String -> DynP ()
deprecate :: [Char] -> DynP ()
deprecate [Char]
s = do
    arg <- EwM (CmdLineP DynFlags) [Char]
forall (m :: * -> *). Monad m => EwM m [Char]
getArg
    addFlagWarn (DriverDeprecatedFlag arg s)

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

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

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

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

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

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

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

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

wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps :: [(Deprecation, FlagSpec WarningFlag)]
wWarningFlagsDeps = [WarningFlag
forall a. Bounded a => a
minBound..WarningFlag
forall a. Bounded a => a
maxBound] [WarningFlag]
-> (WarningFlag -> [(Deprecation, FlagSpec WarningFlag)])
-> [(Deprecation, FlagSpec WarningFlag)]
forall a b. [a] -> (a -> [b]) -> [b]
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \WarningFlag
x -> case WarningFlag
x of
-- See Note [Updating flag description in the User's Guide]
-- See Note [Supporting CLI completion]
  WarningFlag
Opt_WarnAlternativeLayoutRuleTransitional -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnAmbiguousFields -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnAutoOrphans -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"it has no effect"
  WarningFlag
Opt_WarnCPPUndef -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnBadlyStagedTypes -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnbangedStrictPatterns -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDeferredTypeErrors -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDeferredOutOfScopeVariables -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDeprecatedFlags -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDerivingDefaults -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDerivingTypeable -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDodgyExports -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDodgyForeignImports -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDodgyImports -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnEmptyEnumerations -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDuplicateConstraints
    -> [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
"duplicate-constraints" WarningFlag
x [Char]
"it is subsumed by -Wredundant-constraints"
  WarningFlag
Opt_WarnRedundantConstraints -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDuplicateExports -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnHiShadows
    -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"it is not used, and was never implemented"
  WarningFlag
Opt_WarnInaccessibleCode -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnImplicitPrelude -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnImplicitKindVars -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"it is now an error"
  WarningFlag
Opt_WarnIncompletePatterns -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnIncompletePatternsRecUpd -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnIncompleteUniPatterns -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnInconsistentFlags -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnInlineRuleShadowing -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnIdentities -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnLoopySuperclassSolve -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"it is now an error"
  WarningFlag
Opt_WarnMissingFields -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingImportList -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingExportList -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingLocalSignatures
    -> [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
"missing-local-sigs" WarningFlag
x
                   [Char]
"it is replaced by -Wmissing-local-signatures"
       [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, FlagSpec WarningFlag)]
forall a. [a] -> [a] -> [a]
++ WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingMethods -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingMonadFailInstances
    -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"fail is no longer a method of Monad"
  WarningFlag
Opt_WarnSemigroup -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"Semigroup is now a superclass of Monoid"
  WarningFlag
Opt_WarnMissingSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingKindSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingPolyKindSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingExportedSignatures
    -> [Char]
-> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
subWarnSpec [Char]
"missing-exported-sigs" WarningFlag
x
                   [Char]
"it is replaced by -Wmissing-exported-signatures"
       [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, FlagSpec WarningFlag)]
-> [(Deprecation, FlagSpec WarningFlag)]
forall a. [a] -> [a] -> [a]
++ WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMonomorphism -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnNameShadowing -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnNonCanonicalMonadInstances -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnNonCanonicalMonadFailInstances
    -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"fail is no longer a method of Monad"
  WarningFlag
Opt_WarnNonCanonicalMonoidInstances -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnOrphans -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnOverflowedLiterals -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnOverlappingPatterns -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissedSpecs -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnAllMissedSpecs -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnSafe -> WarningFlag
-> (TurnOnFlag -> DynP ()) -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec' WarningFlag
x TurnOnFlag -> DynP ()
setWarnSafe
  WarningFlag
Opt_WarnTrustworthySafe -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnInferredSafeImports -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingSafeHaskellMode -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnTabs -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnTypeDefaults -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnTypedHoles -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnPartialTypeSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnrecognisedPragmas -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMisplacedPragmas -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnsafe -> WarningFlag
-> (TurnOnFlag -> DynP ()) -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec' WarningFlag
x TurnOnFlag -> DynP ()
setWarnUnsafe
  WarningFlag
Opt_WarnUnsupportedCallingConventions -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnsupportedLlvmVersion -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissedExtraSharedLib -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUntickedPromotedConstructors -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedDoBind -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedForalls -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedImports -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedLocalBinds -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedMatches -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedPatternBinds -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedTopBinds -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedTypePatterns -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedRecordWildcards -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnRedundantBangPatterns -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnRedundantRecordWildcards -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnRedundantStrictnessFlags -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnWrongDoBind -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingPatternSynonymSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingDerivingStrategies -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnSimplifiableClassConstraints -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingHomeModules -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnrecognisedWarningFlags -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnStarBinder -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnStarIsType -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnSpaceAfterBang
    -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"bang patterns can no longer be written with a space"
  WarningFlag
Opt_WarnPartialFields -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnPrepositiveQualifiedModule -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnUnusedPackages -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnCompatUnqualifiedImports ->
    WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"This warning no longer does anything; see GHC #24904"
  WarningFlag
Opt_WarnInvalidHaddock -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnOperatorWhitespaceExtConflict -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnOperatorWhitespace -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnImplicitLift -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingExportedPatternSynonymSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnForallIdentifier
    -> WarningFlag -> [Char] -> [(Deprecation, FlagSpec WarningFlag)]
depWarnSpec WarningFlag
x [Char]
"forall is no longer a valid identifier"
  WarningFlag
Opt_WarnUnicodeBidirectionalFormatCharacters -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnGADTMonoLocalBinds -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnTypeEqualityOutOfScope -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnTypeEqualityRequiresOperators -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnTermVariableCapture -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnMissingRoleAnnotations -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnImplicitRhsQuantification -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnIncompleteExportWarnings -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnIncompleteRecordSelectors -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDataKindsTC -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnDefaultedExceptionContext -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x
  WarningFlag
Opt_WarnViewPatternSignatures -> WarningFlag -> [(Deprecation, FlagSpec WarningFlag)]
warnSpec WarningFlag
x

warningGroupsDeps :: [(Deprecation, FlagSpec WarningGroup)]
warningGroupsDeps :: [(Deprecation, FlagSpec WarningGroup)]
warningGroupsDeps = (WarningGroup -> (Deprecation, FlagSpec WarningGroup))
-> [WarningGroup] -> [(Deprecation, FlagSpec WarningGroup)]
forall a b. (a -> b) -> [a] -> [b]
map WarningGroup -> (Deprecation, FlagSpec WarningGroup)
mk [WarningGroup]
warningGroups
  where
    mk :: WarningGroup -> (Deprecation, FlagSpec WarningGroup)
mk WarningGroup
g = (Deprecation
NotDeprecated, [Char]
-> WarningGroup
-> (TurnOnFlag -> DynP ())
-> GhcFlagMode
-> FlagSpec WarningGroup
forall flag.
[Char]
-> flag -> (TurnOnFlag -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec (WarningGroup -> [Char]
warningGroupName WarningGroup
g) WarningGroup
g TurnOnFlag -> DynP ()
nop GhcFlagMode
AllModes)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

makeExtensionFlags :: LangExt.Extension -> [(Deprecation, FlagSpec LangExt.Extension)]
makeExtensionFlags :: Extension -> [(Deprecation, FlagSpec Extension)]
makeExtensionFlags Extension
ext = [ [Char]
-> ExtensionDeprecation
-> Extension
-> (Deprecation, FlagSpec Extension)
makeExtensionFlag [Char]
name ExtensionDeprecation
depr Extension
ext | (ExtensionDeprecation
depr, [Char]
name) <- Extension -> [(ExtensionDeprecation, [Char])]
extensionNames Extension
ext ]

xFlagsDeps :: [(Deprecation, FlagSpec LangExt.Extension)]
xFlagsDeps :: [(Deprecation, FlagSpec Extension)]
xFlagsDeps = (Extension -> [(Deprecation, FlagSpec Extension)])
-> [Extension] -> [(Deprecation, FlagSpec Extension)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap Extension -> [(Deprecation, FlagSpec Extension)]
makeExtensionFlags [Extension
forall a. Bounded a => a
minBound .. Extension
forall a. Bounded a => a
maxBound]

makeExtensionFlag :: String -> ExtensionDeprecation -> LangExt.Extension -> (Deprecation, FlagSpec LangExt.Extension)
makeExtensionFlag :: [Char]
-> ExtensionDeprecation
-> Extension
-> (Deprecation, FlagSpec Extension)
makeExtensionFlag [Char]
name ExtensionDeprecation
depr Extension
ext = (ExtensionDeprecation -> Deprecation
deprecation ExtensionDeprecation
depr, FlagSpec Extension
spec)
  where effect :: TurnOnFlag -> DynP ()
effect = Extension -> TurnOnFlag -> DynP ()
extensionEffect Extension
ext
        spec :: FlagSpec Extension
spec = [Char]
-> Extension
-> (TurnOnFlag -> DynP ())
-> GhcFlagMode
-> FlagSpec Extension
forall flag.
[Char]
-> flag -> (TurnOnFlag -> DynP ()) -> GhcFlagMode -> FlagSpec flag
FlagSpec [Char]
name Extension
ext (\TurnOnFlag
f -> TurnOnFlag -> DynP ()
effect TurnOnFlag
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
>> TurnOnFlag -> DynP ()
act TurnOnFlag
f) GhcFlagMode
AllModes
        act :: TurnOnFlag -> DynP ()
act = case ExtensionDeprecation
depr of
                ExtensionDeprecation
ExtensionNotDeprecated -> TurnOnFlag -> DynP ()
nop
                ExtensionDeprecatedFor [Extension]
xs
                  -> [Char] -> DynP ()
deprecate ([Char] -> DynP ())
-> (TurnOnFlag -> [Char]) -> TurnOnFlag -> DynP ()
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [[Char]] -> TurnOnFlag -> [Char]
deprecatedForExtensions ((Extension -> [Char]) -> [Extension] -> [[Char]]
forall a b. (a -> b) -> [a] -> [b]
map Extension -> [Char]
extensionName [Extension]
xs)
                ExtensionFlagDeprecatedCond TurnOnFlag
cond [Char]
str
                  -> \TurnOnFlag
f -> TurnOnFlag -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => TurnOnFlag -> f () -> f ()
when (TurnOnFlag
f TurnOnFlag -> TurnOnFlag -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== TurnOnFlag
cond) ([Char] -> DynP ()
deprecate [Char]
str)
                ExtensionFlagDeprecated [Char]
str
                  -> DynP () -> TurnOnFlag -> DynP ()
forall a b. a -> b -> a
const ([Char] -> DynP ()
deprecate [Char]
str)

extensionEffect :: LangExt.Extension -> (TurnOnFlag -> DynP ())
extensionEffect :: Extension -> TurnOnFlag -> DynP ()
extensionEffect = \case
  Extension
LangExt.TemplateHaskell
    -> TurnOnFlag -> DynP ()
checkTemplateHaskellOk
  Extension
LangExt.OverlappingInstances
    -> TurnOnFlag -> DynP ()
setOverlappingInsts
  Extension
LangExt.GeneralizedNewtypeDeriving
    -> TurnOnFlag -> DynP ()
setGenDeriving
  Extension
LangExt.IncoherentInstances
    -> TurnOnFlag -> DynP ()
setIncoherentInsts
  Extension
LangExt.DerivingVia
    -> TurnOnFlag -> DynP ()
setDeriveVia
  Extension
_ -> TurnOnFlag -> DynP ()
nop

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

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

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


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

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

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

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

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

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

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

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

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

type DynP = EwM (CmdLineP DynFlags)

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

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

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

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

hasArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg :: ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
hasArg [Char] -> DynFlags -> DynFlags
fn = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
HasArg ((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
fn)

sepArg :: (String -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg :: ([Char] -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
sepArg [Char] -> DynFlags -> DynFlags
fn = ([Char] -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). ([Char] -> EwM m ()) -> OptKind m
SepArg ((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
fn)

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

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

word64Suffix :: (Word64 -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
word64Suffix :: (Word64 -> DynFlags -> DynFlags) -> OptKind (CmdLineP DynFlags)
word64Suffix Word64 -> DynFlags -> DynFlags
fn = (Word64 -> DynP ()) -> OptKind (CmdLineP DynFlags)
forall (m :: * -> *). (Word64 -> EwM m ()) -> OptKind m
Word64Suffix (\Word64
n -> (DynFlags -> DynFlags) -> DynP ()
upd (Word64 -> DynFlags -> DynFlags
fn Word64
n))

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

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

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

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

addWay' :: Way -> DynFlags -> DynFlags
addWay' :: Way -> DynFlags -> DynFlags
addWay' Way
w DynFlags
dflags0 =
   let platform :: Platform
platform = DynFlags -> Platform
targetPlatform DynFlags
dflags0
       dflags1 :: DynFlags
dflags1 = DynFlags
dflags0 { targetWays_ = addWay w (targetWays_ dflags0) }
       dflags2 :: DynFlags
dflags2 = (GeneralFlag -> DynFlags -> DynFlags)
-> DynFlags -> [GeneralFlag] -> DynFlags
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 -> DynFlags
setGeneralFlag' DynFlags
dflags1
                       (Platform -> Way -> [GeneralFlag]
wayGeneralFlags Platform
platform Way
w)
       dflags3 :: DynFlags
dflags3 = (GeneralFlag -> DynFlags -> DynFlags)
-> DynFlags -> [GeneralFlag] -> DynFlags
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 -> DynFlags
unSetGeneralFlag' DynFlags
dflags2
                       (Platform -> Way -> [GeneralFlag]
wayUnsetGeneralFlags Platform
platform Way
w)
   in DynFlags
dflags3

removeWayDynP :: Way -> DynP ()
removeWayDynP :: Way -> DynP ()
removeWayDynP Way
w = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags
dfs { targetWays_ = removeWay w (targetWays_ dfs) })

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

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

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

--------------------------
setWarningGroup :: WarningGroup -> DynP ()
setWarningGroup :: WarningGroup -> DynP ()
setWarningGroup WarningGroup
g = do
    (WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setWarningFlag (WarningGroup -> [WarningFlag]
warningGroupFlags WarningGroup
g)
    TurnOnFlag -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => TurnOnFlag -> f () -> f ()
when (WarningGroup -> TurnOnFlag
warningGroupIncludesExtendedWarnings WarningGroup
g) (DynP () -> DynP ()) -> DynP () -> DynP ()
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> DynP ()
upd DynFlags -> DynFlags
wopt_set_all_custom

unSetWarningGroup :: WarningGroup -> DynP ()
unSetWarningGroup :: WarningGroup -> DynP ()
unSetWarningGroup WarningGroup
g = do
    (WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetWarningFlag (WarningGroup -> [WarningFlag]
warningGroupFlags WarningGroup
g)
    TurnOnFlag -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => TurnOnFlag -> f () -> f ()
when (WarningGroup -> TurnOnFlag
warningGroupIncludesExtendedWarnings WarningGroup
g) (DynP () -> DynP ()) -> DynP () -> DynP ()
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> DynP ()
upd DynFlags -> DynFlags
wopt_unset_all_custom

setWErrorWarningGroup :: WarningGroup -> DynP ()
setWErrorWarningGroup :: WarningGroup -> DynP ()
setWErrorWarningGroup WarningGroup
g =
  do { WarningGroup -> DynP ()
setWarningGroup WarningGroup
g
     ; WarningGroup -> DynP ()
setFatalWarningGroup WarningGroup
g }

setFatalWarningGroup :: WarningGroup -> DynP ()
setFatalWarningGroup :: WarningGroup -> DynP ()
setFatalWarningGroup WarningGroup
g = do
    (WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
setFatalWarningFlag (WarningGroup -> [WarningFlag]
warningGroupFlags WarningGroup
g)
    TurnOnFlag -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => TurnOnFlag -> f () -> f ()
when (WarningGroup -> TurnOnFlag
warningGroupIncludesExtendedWarnings WarningGroup
g) (DynP () -> DynP ()) -> DynP () -> DynP ()
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> DynP ()
upd DynFlags -> DynFlags
wopt_set_all_fatal_custom

unSetFatalWarningGroup :: WarningGroup -> DynP ()
unSetFatalWarningGroup :: WarningGroup -> DynP ()
unSetFatalWarningGroup WarningGroup
g = do
    (WarningFlag -> DynP ()) -> [WarningFlag] -> DynP ()
forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ WarningFlag -> DynP ()
unSetFatalWarningFlag (WarningGroup -> [WarningFlag]
warningGroupFlags WarningGroup
g)
    TurnOnFlag -> DynP () -> DynP ()
forall (f :: * -> *). Applicative f => TurnOnFlag -> f () -> f ()
when (WarningGroup -> TurnOnFlag
warningGroupIncludesExtendedWarnings WarningGroup
g) (DynP () -> DynP ()) -> DynP () -> DynP ()
forall a b. (a -> b) -> a -> b
$ (DynFlags -> DynFlags) -> DynP ()
upd DynFlags -> DynFlags
wopt_unset_all_fatal_custom


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

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

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


setCustomWarningFlag, unSetCustomWarningFlag :: WarningCategory -> DynP ()
setCustomWarningFlag :: WarningCategory -> DynP ()
setCustomWarningFlag   WarningCategory
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningCategory -> DynFlags
wopt_set_custom DynFlags
dfs WarningCategory
f)
unSetCustomWarningFlag :: WarningCategory -> DynP ()
unSetCustomWarningFlag WarningCategory
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningCategory -> DynFlags
wopt_unset_custom DynFlags
dfs WarningCategory
f)

setCustomFatalWarningFlag, unSetCustomFatalWarningFlag :: WarningCategory -> DynP ()
setCustomFatalWarningFlag :: WarningCategory -> DynP ()
setCustomFatalWarningFlag   WarningCategory
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningCategory -> DynFlags
wopt_set_fatal_custom DynFlags
dfs WarningCategory
f)
unSetCustomFatalWarningFlag :: WarningCategory -> DynP ()
unSetCustomFatalWarningFlag WarningCategory
f = (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
dfs -> DynFlags -> WarningCategory -> DynFlags
wopt_unset_fatal_custom DynFlags
dfs WarningCategory
f)

setCustomWErrorFlag :: WarningCategory -> DynP ()
setCustomWErrorFlag :: WarningCategory -> DynP ()
setCustomWErrorFlag WarningCategory
flag =
  do { WarningCategory -> DynP ()
setCustomWarningFlag WarningCategory
flag
     ; WarningCategory -> DynP ()
setCustomFatalWarningFlag WarningCategory
flag }


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

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

    setExtension :: OnOff LangExt.Extension -> DynFlags -> DynFlags
    setExtension :: OnOff Extension -> DynFlags -> DynFlags
setExtension = \ case
      On Extension
extension -> Extension -> DynFlags -> DynFlags
setExtensionFlag' Extension
extension
      Off Extension
extension -> Extension -> DynFlags -> DynFlags
unSetExtensionFlag' Extension
extension

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

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

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

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

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


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

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

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

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

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

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

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

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

trustPackage :: [Char] -> DynP ()
trustPackage [Char]
p = [Char] -> DynP ()
exposePackage [Char]
p 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
>> -- both trust and distrust also expose a package
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ trustFlags = TrustPackage p : trustFlags s })
distrustPackage :: [Char] -> DynP ()
distrustPackage [Char]
p = [Char] -> DynP ()
exposePackage [Char]
p 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
>>
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ trustFlags = DistrustPackage p : trustFlags s })

exposePackage' :: String -> DynFlags -> DynFlags
exposePackage' :: [Char] -> DynFlags -> DynFlags
exposePackage' [Char]
p DynFlags
dflags
    = DynFlags
dflags { packageFlags =
            parsePackageFlag "-package" parsePackageArg p : packageFlags dflags }

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

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

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

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

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

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

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

-}

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

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

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

addReexportedModule :: String -> DynP ()
addReexportedModule :: [Char] -> DynP ()
addReexportedModule [Char]
p =
  (DynFlags -> DynFlags) -> DynP ()
upd (\DynFlags
s -> DynFlags
s{ reexportedModules  = (parseReexportedModule p) : (reexportedModules s) })

parseReexportedModule :: String                 -- string to parse
                      -> ReexportedModule
parseReexportedModule :: [Char] -> ReexportedModule
parseReexportedModule [Char]
str
 = case ((ReexportedModule, [Char]) -> TurnOnFlag)
-> [(ReexportedModule, [Char])] -> [(ReexportedModule, [Char])]
forall a. (a -> TurnOnFlag) -> [a] -> [a]
filter (([Char] -> [Char] -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
==[Char]
"")([Char] -> TurnOnFlag)
-> ((ReexportedModule, [Char]) -> [Char])
-> (ReexportedModule, [Char])
-> TurnOnFlag
forall b c a. (b -> c) -> (a -> b) -> a -> c
.(ReexportedModule, [Char]) -> [Char]
forall a b. (a, b) -> b
snd) (ReadP ReexportedModule -> ReadS ReexportedModule
forall a. ReadP a -> ReadS a
readP_to_S ReadP ReexportedModule
parseItem [Char]
str) of
    [(ReexportedModule
r, [Char]
"")] -> ReexportedModule
r
    [(ReexportedModule, [Char])]
_ -> GhcException -> ReexportedModule
forall a. GhcException -> a
throwGhcException (GhcException -> ReexportedModule)
-> GhcException -> ReexportedModule
forall a b. (a -> b) -> a -> b
$ [Char] -> GhcException
CmdLineError ([Char]
"Can't parse reexported module flag: " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
str)
  where
        parseItem :: ReadP ReexportedModule
parseItem = do
            orig <- ReadP ModuleName -> ReadP ModuleName
forall {b}. ReadP b -> ReadP b
tok (ReadP ModuleName -> ReadP ModuleName)
-> ReadP ModuleName -> ReadP ModuleName
forall a b. (a -> b) -> a -> b
$ ReadP ModuleName
parseModuleName
            (do _ <- tok $ string "as"
                new <- tok $ parseModuleName
                return (ReexportedModule orig new))
              +++
             return (ReexportedModule orig orig)

        tok :: ReadP b -> ReadP b
tok ReadP b
m = ReadP b
m ReadP b -> (b -> ReadP b) -> ReadP b
forall a b. ReadP a -> (a -> ReadP b) -> ReadP b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \b
x -> ReadP ()
skipSpaces ReadP () -> ReadP b -> ReadP b
forall a b. ReadP a -> ReadP b -> ReadP b
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> b -> ReadP b
forall a. a -> ReadP a
forall (m :: * -> *) a. Monad m => a -> m a
return b
x


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

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

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

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

setMainIs :: String -> DynP ()
setMainIs :: [Char] -> DynP ()
setMainIs [Char]
arg = (RdrName -> DynP ()) -> [Char] -> DynP ()
parse RdrName -> DynP ()
parse_main_f [Char]
arg
  where
    parse :: (RdrName -> DynP ()) -> [Char] -> DynP ()
parse RdrName -> DynP ()
callback [Char]
str = case P (LocatedN RdrName) -> PState -> ParseResult (LocatedN RdrName)
forall a. P a -> PState -> ParseResult a
unP P (LocatedN RdrName)
parseIdentifier ([Char] -> PState
p_state [Char]
str) of
      PFailed PState
_      -> [Char] -> DynP ()
forall (m :: * -> *). Monad m => [Char] -> EwM m ()
addErr ([Char] -> DynP ()) -> [Char] -> DynP ()
forall a b. (a -> b) -> a -> b
$ [Char]
"Can't parse -main-is \"" [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
arg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
"\" as an identifier or module."
      POk PState
_ (L SrcSpanAnnN
_ RdrName
re) -> RdrName -> DynP ()
callback RdrName
re

    -- dummy parser state.
    p_state :: [Char] -> PState
p_state [Char]
str = ParserOpts -> StringBuffer -> RealSrcLoc -> PState
initParserState
              (EnumSet Extension
-> DiagOpts
-> TurnOnFlag
-> TurnOnFlag
-> TurnOnFlag
-> TurnOnFlag
-> ParserOpts
mkParserOpts EnumSet Extension
forall a. Monoid a => a
mempty DiagOpts
emptyDiagOpts TurnOnFlag
False TurnOnFlag
False TurnOnFlag
False TurnOnFlag
True)
              ([Char] -> StringBuffer
stringToStringBuffer [Char]
str)
              (FastString -> Int -> Int -> RealSrcLoc
mkRealSrcLoc ([Char] -> FastString
mkFastString []) Int
1 Int
1)

    parse_main_f :: RdrName -> DynP ()
parse_main_f (Unqual OccName
occ)
      | OccName -> TurnOnFlag
isVarOcc OccName
occ = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainFunIs = main_f occ }
    parse_main_f (Qual (ModuleName FastString
mod) OccName
occ)
      | OccName -> TurnOnFlag
isVarOcc OccName
occ = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainModuleNameIs = mkModuleNameFS mod
                                     , mainFunIs = main_f occ }
    -- append dummy "function" to parse A.B as the module A.B
    -- and not the Data constructor B from the module A
    parse_main_f RdrName
_ = (RdrName -> DynP ()) -> [Char] -> DynP ()
parse RdrName -> DynP ()
parse_mod ([Char]
arg [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++ [Char]
".main")

    main_f :: OccName -> Maybe [Char]
main_f = [Char] -> Maybe [Char]
forall a. a -> Maybe a
Just ([Char] -> Maybe [Char])
-> (OccName -> [Char]) -> OccName -> Maybe [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OccName -> [Char]
occNameString

    parse_mod :: RdrName -> DynP ()
parse_mod (Qual (ModuleName FastString
mod) OccName
_) = (DynFlags -> DynFlags) -> DynP ()
upd ((DynFlags -> DynFlags) -> DynP ())
-> (DynFlags -> DynFlags) -> DynP ()
forall a b. (a -> b) -> a -> b
$ \DynFlags
d -> DynFlags
d { mainModuleNameIs = mkModuleNameFS mod }
    -- we appended ".m" and any parse error was caught. We are Qual or something went very wrong
    parse_mod RdrName
_ = [Char] -> DynP ()
forall a. HasCallStack => [Char] -> a
error [Char]
"unreachable"

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

       | GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_PIC DynFlags
dflags -> [[Char]
"-fno-common", [Char]
"-U__PIC__", [Char]
"-D__PIC__"]
       | TurnOnFlag
otherwise           -> [[Char]
"-mdynamic-no-pic"]
      OS
OSMinGW32 -- no -fPIC for Windows
       | GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_PIC DynFlags
dflags -> [[Char]
"-U__PIC__", [Char]
"-D__PIC__"]
       | TurnOnFlag
otherwise           -> []
      OS
_
      -- we need -fPIC for C files when we are compiling with -dynamic,
      -- otherwise things like stub.c files don't get compiled
      -- correctly.  They need to reference data in the Haskell
      -- objects, but can't without -fPIC.  See
      -- https://gitlab.haskell.org/ghc/ghc/wikis/commentary/position-independent-code
       | GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_PIC DynFlags
dflags TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| DynFlags -> Set Way
ways DynFlags
dflags Set Way -> Way -> TurnOnFlag
`hasWay` Way
WayDyn ->
          [[Char]
"-fPIC", [Char]
"-U__PIC__", [Char]
"-D__PIC__"] [[Char]] -> [[Char]] -> [[Char]]
forall a. [a] -> [a] -> [a]
++
          -- Clang defaults to -fvisibility=hidden for wasm targets,
          -- but we need these compile-time flags to generate PIC
          -- objects that can be properly linked by wasm-ld using
          -- --export-dynamic; without these flags we would need
          -- -Wl,--export-all at .so link-time which will export
          -- internal symbols as well, and that severely pollutes the
          -- global symbol namespace.
          (if Platform -> Arch
platformArch (DynFlags -> Platform
targetPlatform DynFlags
dflags) Arch -> Arch -> TurnOnFlag
forall a. Eq a => a -> a -> TurnOnFlag
== Arch
ArchWasm32
            then [ [Char]
"-fvisibility=default", [Char]
"-fvisibility-inlines-hidden" ]
            else [])
      -- gcc may be configured to have PIC on by default, let's be
      -- explicit here, see #15847
       | TurnOnFlag
otherwise -> [[Char]
"-fno-PIC"]

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 | Backend -> TurnOnFlag
backendForcesOptimization0 (DynFlags -> Backend
backend DynFlags
dflags)
 , GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_UnoptimizedCoreForInterpreter DynFlags
dflags
 , let (DynFlags
dflags', TurnOnFlag
changed) = Int -> DynFlags -> (DynFlags, TurnOnFlag)
updOptLevelChanged Int
0 DynFlags
dflags
 , TurnOnFlag
changed
    = DynFlags -> [Char] -> (DynFlags, [Warn])
loop DynFlags
dflags' ([Char] -> (DynFlags, [Warn])) -> [Char] -> (DynFlags, [Warn])
forall a b. (a -> b) -> a -> b
$
      [Char]
"Ignoring optimization flags since they are experimental for the " [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
      Backend -> [Char]
backendDescription (DynFlags -> Backend
backend DynFlags
dflags) [Char] -> [Char] -> [Char]
forall a. [a] -> [a] -> [a]
++
      [Char]
". Pass -fno-unoptimized-core-for-interpreter to enable this feature."

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

 | GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_ByteCode DynFlags
dflags TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_ByteCodeAndObjectCode DynFlags
dflags
 , TurnOnFlag -> TurnOnFlag
not (GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_ExternalInterpreter DynFlags
dflags)
 , TurnOnFlag
hostIsProfiled
 , DynFlags -> Set Way
ways DynFlags
dflags Set Way -> Way -> TurnOnFlag
`hasNotWay` Way
WayProf
    = DynFlags -> [Char] -> (DynFlags, [Warn])
loop (DynFlags -> GeneralFlag -> DynFlags
gopt_set DynFlags
dflags GeneralFlag
Opt_ExternalInterpreter)
         [Char]
"Enabling external interpreter, because GHC is profiled and bytecode is being used for TH"

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

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


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


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

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

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

                       -- Source ticks are used to approximate the location of
                       -- overloaded call cost centers
                       TurnOnFlag -> TurnOnFlag -> TurnOnFlag
|| GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_ProfLateoverloadedCallsCCs DynFlags
dflags

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

-- | Should we use `-XLinker -rpath` when linking or not?
-- See Note [-fno-use-rpaths]
useXLinkerRPath :: DynFlags -> OS -> Bool
-- wasm shared libs don't have RPATH at all and wasm-ld doesn't accept
-- any RPATH-related flags
useXLinkerRPath :: DynFlags -> OS -> TurnOnFlag
useXLinkerRPath DynFlags
dflags OS
_ | Arch
ArchWasm32 <- Platform -> Arch
platformArch (Platform -> Arch) -> Platform -> Arch
forall a b. (a -> b) -> a -> b
$ DynFlags -> Platform
targetPlatform DynFlags
dflags = TurnOnFlag
False
useXLinkerRPath DynFlags
_ OS
OSDarwin = TurnOnFlag
False -- See Note [Dynamic linking on macOS]
useXLinkerRPath DynFlags
dflags OS
_ = GeneralFlag -> DynFlags -> TurnOnFlag
gopt GeneralFlag
Opt_RPath DynFlags
dflags

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

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

The specification of `Opt_RPath` is as follows:

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

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

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

-}

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

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

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

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

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

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

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